blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
51959747d44c2ddfc490f4b1d33412d3d704e2a9 | 24f37f27b5c53772ceb5cccb07135ec6e68c3823 | /powerloss.cpp | f917fa84e16eb73c57f68b34036c0aea476288eb | [] | no_license | 8Moshe8/Home-Z-safely-during-power-loss-recovery | abdd911014738af5d6864a198ceb94fd1d830a90 | 458c1f20f3657f4c5290404700b2250ea3d827c2 | refs/heads/master | 2022-10-22T20:26:38.156268 | 2020-06-08T22:05:07 | 2020-06-08T22:05:07 | 270,840,299 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,344 | cpp | /**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
/**
* power_loss_recovery.cpp - Resume an SD print after power-loss
*/
#include "../inc/MarlinConfigPre.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "powerloss.h"
#include "../core/macros.h"
bool PrintJobRecovery::enabled; // Initialized by settings.load()
SdFile PrintJobRecovery::file;
job_recovery_info_t PrintJobRecovery::info;
const char PrintJobRecovery::filename[5] = "/PLR";
uint8_t PrintJobRecovery::queue_index_r;
uint32_t PrintJobRecovery::cmd_sdpos, // = 0
PrintJobRecovery::sdpos[BUFSIZE];
#include "../sd/cardreader.h"
#include "../lcd/ultralcd.h"
#include "../gcode/queue.h"
#include "../gcode/gcode.h"
#include "../module/motion.h"
#include "../module/planner.h"
#include "../module/printcounter.h"
#include "../module/temperature.h"
#include "../core/serial.h"
#if ENABLED(FWRETRACT)
#include "fwretract.h"
#endif
#define DEBUG_OUT ENABLED(DEBUG_POWER_LOSS_RECOVERY)
#include "../core/debug_out.h"
PrintJobRecovery recovery;
#ifndef POWER_LOSS_PURGE_LEN
#define POWER_LOSS_PURGE_LEN 0
#endif
#ifndef POWER_LOSS_RETRACT_LEN
#define POWER_LOSS_RETRACT_LEN 0
#endif
#ifndef POWER_LOSS_ZRAISE
#define POWER_LOSS_ZRAISE 2
#endif
/**
* Clear the recovery info
*/
void PrintJobRecovery::init() { memset(&info, 0, sizeof(info)); }
/**
* Enable or disable then call changed()
*/
void PrintJobRecovery::enable(const bool onoff) {
enabled = onoff;
changed();
}
/**
* The enabled state was changed:
* - Enabled: Purge the job recovery file
* - Disabled: Write the job recovery file
*/
void PrintJobRecovery::changed() {
if (!enabled)
purge();
else if (IS_SD_PRINTING())
save(true);
}
/**
* Check for Print Job Recovery during setup()
*
* If a saved state exists send 'M1000 S' to initiate job recovery.
*/
void PrintJobRecovery::check() {
//if (!card.isMounted()) card.mount();
if (card.isMounted()) {
load();
if (!valid()) return purge();
queue.inject_P(PSTR("M1000 S"));
}
}
/**
* Delete the recovery file and clear the recovery data
*/
void PrintJobRecovery::purge() {
init();
card.removeJobRecoveryFile();
}
/**
* Load the recovery data, if it exists
*/
void PrintJobRecovery::load() {
if (exists()) {
open(true);
(void)file.read(&info, sizeof(info));
close();
}
debug(PSTR("Load"));
}
/**
* Set info fields that won't change
*/
void PrintJobRecovery::prepare() {
card.getAbsFilename(info.sd_filename); // SD filename
cmd_sdpos = 0;
}
/**
* Save the current machine state to the power-loss recovery file
*/
void PrintJobRecovery::save(const bool force/*=false*/) {
#if SAVE_INFO_INTERVAL_MS > 0
static millis_t next_save_ms; // = 0
millis_t ms = millis();
#endif
#ifndef POWER_LOSS_MIN_Z_CHANGE
#define POWER_LOSS_MIN_Z_CHANGE 0.05 // Vase-mode-friendly out of the box
#endif
// Did Z change since the last call?
if (force
#if DISABLED(SAVE_EACH_CMD_MODE) // Always save state when enabled
#if SAVE_INFO_INTERVAL_MS > 0 // Save if interval is elapsed
|| ELAPSED(ms, next_save_ms)
#endif
// Save if Z is above the last-saved position by some minimum height
|| current_position.z > info.current_position.z + POWER_LOSS_MIN_Z_CHANGE
#endif
) {
#if SAVE_INFO_INTERVAL_MS > 0
next_save_ms = ms + SAVE_INFO_INTERVAL_MS;
#endif
// Set Head and Foot to matching non-zero values
if (!++info.valid_head) ++info.valid_head; // non-zero in sequence
//if (!IS_SD_PRINTING()) info.valid_head = 0;
info.valid_foot = info.valid_head;
// Machine state
info.current_position = current_position;
#if HAS_HOME_OFFSET
info.home_offset = home_offset;
#endif
#if HAS_POSITION_SHIFT
info.position_shift = position_shift;
#endif
info.feedrate = uint16_t(feedrate_mm_s * 60.0f);
#if EXTRUDERS > 1
info.active_extruder = active_extruder;
#endif
#if DISABLED(NO_VOLUMETRICS)
info.volumetric_enabled = parser.volumetric_enabled;
#if EXTRUDERS > 1
for (int8_t e = 0; e < EXTRUDERS; e++) info.filament_size[e] = planner.filament_size[e];
#else
if (parser.volumetric_enabled) info.filament_size = planner.filament_size[active_extruder];
#endif
#endif
#if EXTRUDERS
HOTEND_LOOP() info.target_temperature[e] = thermalManager.temp_hotend[e].target;
#endif
#if HAS_HEATED_BED
info.target_temperature_bed = thermalManager.temp_bed.target;
#endif
#if FAN_COUNT
COPY(info.fan_speed, thermalManager.fan_speed);
#endif
#if HAS_LEVELING
info.leveling = planner.leveling_active;
info.fade = (
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
planner.z_fade_height
#else
0
#endif
);
#endif
#if ENABLED(GRADIENT_MIX)
memcpy(&info.gradient, &mixer.gradient, sizeof(info.gradient));
#endif
#if ENABLED(FWRETRACT)
COPY(info.retract, fwretract.current_retract);
info.retract_hop = fwretract.current_hop;
#endif
// Relative axis modes
info.axis_relative = gcode.axis_relative;
// Elapsed print job time
info.print_job_elapsed = print_job_timer.duration();
write();
}
}
#if PIN_EXISTS(POWER_LOSS)
void PrintJobRecovery::_outage() {
#if ENABLED(BACKUP_POWER_SUPPLY)
static bool lock = false;
if (lock) return; // No re-entrance from idle() during raise_z()
lock = true;
#endif
if (IS_SD_PRINTING()) save(true);
#if ENABLED(BACKUP_POWER_SUPPLY)
raise_z();
#endif
kill(GET_TEXT(MSG_OUTAGE_RECOVERY));
}
#if ENABLED(BACKUP_POWER_SUPPLY)
void PrintJobRecovery::raise_z() {
// Disable all heaters to reduce power loss
thermalManager.disable_all_heaters();
quickstop_stepper();
// Raise Z axis
gcode.process_subcommands_now_P(PSTR("G91\nG0 Z" STRINGIFY(POWER_LOSS_ZRAISE)));
planner.synchronize();
}
#endif
#endif
/**
* Save the recovery info the recovery file
*/
void PrintJobRecovery::write() {
debug(PSTR("Write"));
open(false);
file.seekSet(0);
const int16_t ret = file.write(&info, sizeof(info));
if (ret == -1) DEBUG_ECHOLNPGM("Power-loss file write failed.");
if (!file.close()) DEBUG_ECHOLNPGM("Power-loss file close failed.");
}
/**
* Resume the saved print job
*/
void PrintJobRecovery::resume() {
const uint32_t resume_sdpos = info.sdpos; // Get here before the stepper ISR overwrites it
#if HAS_LEVELING
// Make sure leveling is off before any G92 and G28
gcode.process_subcommands_now_P(PSTR("M420 S0 Z0"));
#endif
// Reset E, raise Z, home XY...
gcode.process_subcommands_now_P(PSTR("G92.9 E0"
#if Z_HOME_DIR > 0
// If Z homing goes to max, just reset E and home all
"\n"
"G28R0"
#if ENABLED(MARLIN_DEV_MODE)
"S"
#endif
#else // "G92.9 E0 ..."
// Set Z to 0, raise Z by RECOVERY_ZRAISE, and Home (XY only for Cartesian)
// with no raise. (Only do simulated homing in Marlin Dev Mode.)
#if ENABLED(BACKUP_POWER_SUPPLY)
"Z" STRINGIFY(POWER_LOSS_ZRAISE) // Z-axis was already raised at outage
#else
"Z0\n" // Set Z=0
"G1Z" STRINGIFY(POWER_LOSS_ZRAISE) // Raise Z
#endif
"\n"
"G28R0"
#if ENABLED(MARLIN_DEV_MODE)
"S"
#elif !IS_KINEMATIC
"XY"
#endif
#endif
));
// Pretend that all axes are homed
axis_homed = axis_known_position = xyz_bits;
char cmd[MAX_CMD_SIZE+16], str_1[16], str_2[16];
// if POWER_LOSS_ZHOME is enabled:
#if ENABLED(POWER_LOSS_ZHOME)
// if a safe position for homing Z in XY plane exists, move to it
#if ENABLED(POWER_LOSS_ZHOME_XPOS)
gcode.process_subcommands_now_P( PSTR("G1 F1000 X" STRINGIFY(POWER_LOSS_ZHOME_XPOS)) );
#endif
#if ENABLED(POWER_LOSS_ZHOME_YPOS)
gcode.process_subcommands_now_P( PSTR("G1 F1000 Y" STRINGIFY(POWER_LOSS_ZHOME_YPOS)) );
#endif
// home Z
gcode.process_subcommands_now_P( PSTR("G28 Z") );
// Now move to ZsavedPos + POWER_LOSS_ZRAISE
dtostrf(info.current_position.z + POWER_LOSS_ZRAISE, 1, 3, str_1);
sprintf_P(cmd, PSTR("G1 F200 Z%s"), str_1);
gcode.process_subcommands_now(cmd);
// at the end of this all axis are homed, and hot end above print
#endif
// Select the previously active tool (with no_move)
#if EXTRUDERS > 1
sprintf_P(cmd, PSTR("T%i S"), info.active_extruder);
gcode.process_subcommands_now(cmd);
#endif
// Recover volumetric extrusion state
#if DISABLED(NO_VOLUMETRICS)
#if EXTRUDERS > 1
for (int8_t e = 0; e < EXTRUDERS; e++) {
dtostrf(info.filament_size[e], 1, 3, str_1);
sprintf_P(cmd, PSTR("M200 T%i D%s"), e, str_1);
gcode.process_subcommands_now(cmd);
}
if (!info.volumetric_enabled) {
sprintf_P(cmd, PSTR("M200 T%i D0"), info.active_extruder);
gcode.process_subcommands_now(cmd);
}
#else
if (info.volumetric_enabled) {
dtostrf(info.filament_size, 1, 3, str_1);
sprintf_P(cmd, PSTR("M200 D%s"), str_1);
gcode.process_subcommands_now(cmd);
}
#endif
#endif
#if HAS_HEATED_BED
const int16_t bt = info.target_temperature_bed;
if (bt) {
// Restore the bed temperature
sprintf_P(cmd, PSTR("M190 S%i"), bt);
gcode.process_subcommands_now(cmd);
}
#endif
// Restore all hotend temperatures
#if HOTENDS
HOTEND_LOOP() {
const int16_t et = info.target_temperature[e];
if (et) {
#if HOTENDS > 1
sprintf_P(cmd, PSTR("T%i"), e);
gcode.process_subcommands_now(cmd);
#endif
sprintf_P(cmd, PSTR("M109 S%i"), et);
gcode.process_subcommands_now(cmd);
}
}
#endif
// Restore print cooling fan speeds
FANS_LOOP(i) {
uint8_t f = info.fan_speed[i];
if (f) {
sprintf_P(cmd, PSTR("M106 P%i S%i"), i, f);
gcode.process_subcommands_now(cmd);
}
}
// Restore retract and hop state
#if ENABLED(FWRETRACT)
LOOP_L_N(e, EXTRUDERS) {
if (info.retract[e] != 0.0) {
fwretract.current_retract[e] = info.retract[e];
fwretract.retracted[e] = true;
}
}
fwretract.current_hop = info.retract_hop;
#endif
#if HAS_LEVELING
// Restore leveling state before 'G92 Z' to ensure
// the Z stepper count corresponds to the native Z.
if (info.fade || info.leveling) {
sprintf_P(cmd, PSTR("M420 S%i Z%s"), int(info.leveling), dtostrf(info.fade, 1, 1, str_1));
gcode.process_subcommands_now(cmd);
}
#endif
#if ENABLED(GRADIENT_MIX)
memcpy(&mixer.gradient, &info.gradient, sizeof(info.gradient));
#endif
// Extrude and retract to clean the nozzle
#if POWER_LOSS_PURGE_LEN
//sprintf_P(cmd, PSTR("G1 E%d F200"), POWER_LOSS_PURGE_LEN);
//gcode.process_subcommands_now(cmd);
gcode.process_subcommands_now_P(PSTR("G1 E" STRINGIFY(POWER_LOSS_PURGE_LEN) " F200"));
#endif
#if POWER_LOSS_RETRACT_LEN
sprintf_P(cmd, PSTR("G1 E%d F3000"), POWER_LOSS_PURGE_LEN - (POWER_LOSS_RETRACT_LEN));
gcode.process_subcommands_now(cmd);
#endif
// Move back to the saved XY
sprintf_P(cmd, PSTR("G1 X%s Y%s F3000"),
dtostrf(info.current_position.x, 1, 3, str_1),
dtostrf(info.current_position.y, 1, 3, str_2)
);
gcode.process_subcommands_now(cmd);
// Move back to the saved Z
dtostrf(info.current_position.z, 1, 3, str_1);
#if Z_HOME_DIR > 0
sprintf_P(cmd, PSTR("G1 Z%s F200"), str_1);
#else
dtostrf(info.current_position.z, 1, 3, str_1);
sprintf_P(cmd, PSTR("G1 F200 Z%s"), str_1);
#endif
gcode.process_subcommands_now(cmd);
// Un-retract
#if POWER_LOSS_PURGE_LEN
//sprintf_P(cmd, PSTR("G1 E%d F3000"), POWER_LOSS_PURGE_LEN);
//gcode.process_subcommands_now(cmd);
gcode.process_subcommands_now_P(PSTR("G1 E" STRINGIFY(POWER_LOSS_PURGE_LEN) " F3000"));
#endif
// Restore the feedrate
sprintf_P(cmd, PSTR("G1 F%d"), info.feedrate);
gcode.process_subcommands_now(cmd);
// Restore E position with G92.9
sprintf_P(cmd, PSTR("G92.9 E%s"), dtostrf(info.current_position.e, 1, 3, str_1));
gcode.process_subcommands_now(cmd);
// Relative axis modes
gcode.axis_relative = info.axis_relative;
#if HAS_HOME_OFFSET
home_offset = info.home_offset;
#endif
#if HAS_POSITION_SHIFT
position_shift = info.position_shift;
#endif
#if HAS_HOME_OFFSET || HAS_POSITION_SHIFT
LOOP_XYZ(i) update_workspace_offset((AxisEnum)i);
#endif
// Resume the SD file from the last position
char *fn = info.sd_filename;
extern const char M23_STR[];
sprintf_P(cmd, M23_STR, fn);
gcode.process_subcommands_now(cmd);
sprintf_P(cmd, PSTR("M24 S%ld T%ld"), resume_sdpos, info.print_job_elapsed);
gcode.process_subcommands_now(cmd);
}
#if ENABLED(DEBUG_POWER_LOSS_RECOVERY)
void PrintJobRecovery::debug(PGM_P const prefix) {
DEBUG_PRINT_P(prefix);
DEBUG_ECHOLNPAIR(" Job Recovery Info...\nvalid_head:", int(info.valid_head), " valid_foot:", int(info.valid_foot));
if (info.valid_head) {
if (info.valid_head == info.valid_foot) {
DEBUG_ECHOPGM("current_position: ");
LOOP_XYZE(i) {
if (i) DEBUG_CHAR(',');
DEBUG_ECHO(info.current_position[i]);
}
DEBUG_EOL();
#if HAS_HOME_OFFSET
DEBUG_ECHOPGM("home_offset: ");
LOOP_XYZ(i) {
if (i) DEBUG_CHAR(',');
DEBUG_ECHO(info.home_offset[i]);
}
DEBUG_EOL();
#endif
#if HAS_POSITION_SHIFT
DEBUG_ECHOPGM("position_shift: ");
LOOP_XYZ(i) {
if (i) DEBUG_CHAR(',');
DEBUG_ECHO(info.position_shift[i]);
}
DEBUG_EOL();
#endif
DEBUG_ECHOLNPAIR("feedrate: ", info.feedrate);
#if EXTRUDERS > 1
DEBUG_ECHOLNPAIR("active_extruder: ", int(info.active_extruder));
#endif
#if HOTENDS
DEBUG_ECHOPGM("target_temperature: ");
HOTEND_LOOP() {
DEBUG_ECHO(info.target_temperature[e]);
if (e < HOTENDS - 1) DEBUG_CHAR(',');
}
DEBUG_EOL();
#endif
#if HAS_HEATED_BED
DEBUG_ECHOLNPAIR("target_temperature_bed: ", info.target_temperature_bed);
#endif
#if FAN_COUNT
DEBUG_ECHOPGM("fan_speed: ");
FANS_LOOP(i) {
DEBUG_ECHO(int(info.fan_speed[i]));
if (i < FAN_COUNT - 1) DEBUG_CHAR(',');
}
DEBUG_EOL();
#endif
#if HAS_LEVELING
DEBUG_ECHOLNPAIR("leveling: ", int(info.leveling), "\n fade: ", int(info.fade));
#endif
#if ENABLED(FWRETRACT)
DEBUG_ECHOPGM("retract: ");
for (int8_t e = 0; e < EXTRUDERS; e++) {
DEBUG_ECHO(info.retract[e]);
if (e < EXTRUDERS - 1) DEBUG_CHAR(',');
}
DEBUG_EOL();
DEBUG_ECHOLNPAIR("retract_hop: ", info.retract_hop);
#endif
DEBUG_ECHOLNPAIR("sd_filename: ", info.sd_filename);
DEBUG_ECHOLNPAIR("sdpos: ", info.sdpos);
DEBUG_ECHOLNPAIR("print_job_elapsed: ", info.print_job_elapsed);
}
else
DEBUG_ECHOLNPGM("INVALID DATA");
}
DEBUG_ECHOLNPGM("---");
}
#endif // DEBUG_POWER_LOSS_RECOVERY
#endif // POWER_LOSS_RECOVERY
| [
"noreply@github.com"
] | noreply@github.com |
60c5450bc5f53ae7083e734adabd572220fdba22 | 5d83739af703fb400857cecc69aadaf02e07f8d1 | /Archive2/6f/4c70935194e0de/main.cpp | 8ad5a506a2aa261fd080f4be6a3038e94996aebc | [] | no_license | WhiZTiM/coliru | 3a6c4c0bdac566d1aa1c21818118ba70479b0f40 | 2c72c048846c082f943e6c7f9fa8d94aee76979f | refs/heads/master | 2021-01-01T05:10:33.812560 | 2015-08-24T19:09:22 | 2015-08-24T19:09:22 | 56,789,706 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,039 | cpp | using namespace std;
#include <string>
#include <algorithm>
typedef std::pair<int, std::string> Pair;
struct Cmp
{
bool operator()(Pair const& a, Pair const& b) const { return a.first < b.first; };
bool operator()(Pair const& a, int & b) const { return a.first < b; };
bool operator()(int & a, Pair const& b) const { return a < b.first; };
};
struct SectorSupportsCA
{
std::vector<bool> supportCA;
SectorSupportsCA(std::vector<bool>& sCA)
{
supportCA = sCA;
};
bool operator()(int a) const { return !supportCA[a]; };
};
struct SectorSignalPairEquals : public std::binary_function<Pair, int, bool> {
bool operator()(Pair const& a, int b) const
{
return (a.first == b);
};
};
#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
std::cout << "Executing... \n";
std::vector<Pair> sectorSignals = {
{ 1, "105" },
{ 2, "110" },
{ 3, "115" },
{ 42, "120" },
};
std::vector<bool> supportCA = {
/* 0 */ false,
/* 1 */ false,
/* 2 */ true,
/* 3 */ false,
/* 4 */ true
};
std::vector<int> sCells = { 2, 3, 4 };
std::vector< int > sCellsInNBest(sCells.size());
std::vector< int > sCellsNotInNBest(sCells.size());
Cmp cmp;
std::sort(sectorSignals.begin(), sectorSignals.end(), Cmp());
std::sort(sCells.begin(), sCells.end());
sCells.erase(std::remove_if(sCells.begin(), sCells.end(), SectorSupportsCA(supportCA)), sCells.end());
std::vector<int>::iterator resIt = std::set_intersection (sCells.begin(), sCells.end(), sectorSignals.begin(), sectorSignals.end(), sCellsInNBest.begin(), Cmp());
//auto range = std::equal_range(vec.begin(), vec.end(), std::string("zus"), cmp);
sCellsInNBest.resize(resIt-sCellsInNBest.begin());
if (sCellsInNBest.size() == 0)
{
std::cout << "There is no Secondary Cells in NBest Server";
}
else
{
std::cout << "Secondary Cells: ";
}
std::vector< int >::iterator It = sCellsInNBest.begin();
for(; It!= sCellsInNBest.end(); ++It)
{
std::cout << *It << ", ";
}
std::cout << endl;
SectorSignalPairEquals equals;
std::vector<Pair>::iterator nBestIt;
for(size_t i=0; i<sCellsInNBest.size(); ++i)
{
nBestIt = std::find_if(sectorSignals.begin(), sectorSignals.end(), std::bind2nd(equals, sCellsInNBest[i]));
std::cout << "nBest.first: " << (*nBestIt).first << endl;
std::cout << "nBest.second: " << (*nBestIt).second << endl;
}
sCellsNotInNBest.resize(sCells.size());
resIt = std::set_difference(sCells.begin(), sCells.end(), sCellsInNBest.begin(), sCellsInNBest.end(), sCellsNotInNBest.begin());
sCellsNotInNBest.resize(resIt-sCellsNotInNBest.begin());
// std::vector<Pair>::iterator notInNBestIt;
for(size_t i=0; i<sCellsNotInNBest.size(); ++i)
{
std::cout << "Sector Index: " << sCellsNotInNBest[i] << endl;
}
}
| [
"francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df"
] | francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df |
70686ea5c84587fa6d5b5e2234ae00b676408870 | e1a84cb3300878c6620940a1245fdf16ef66ff67 | /src/cryptonote_basic/account_boost_serialization.h | 1d3632ce1c00992e17d14ae054934ffc595e7cd4 | [
"BSD-3-Clause"
] | permissive | holodnak/masari | e66e7b626c19fb53495b53ce8e02f34af616473d | d6e438dd711119b60aeea5e77f7a138d40fbaf88 | refs/heads/master | 2020-03-08T02:27:28.189846 | 2018-03-26T17:13:11 | 2018-03-26T17:13:11 | 127,860,263 | 0 | 0 | null | 2018-04-03T06:16:15 | 2018-04-03T06:16:15 | null | UTF-8 | C++ | false | false | 2,359 | h | // Copyright (c) 2017-2018, The Masari Project
// Copyright (c) 2014-2017, The Monero Project
//
// 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.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#pragma once
#include "account.h"
#include "cryptonote_boost_serialization.h"
//namespace cryptonote {
namespace boost
{
namespace serialization
{
template <class Archive>
inline void serialize(Archive &a, cryptonote::account_keys &x, const boost::serialization::version_type ver)
{
a & x.m_account_address;
a & x.m_spend_secret_key;
a & x.m_view_secret_key;
}
template <class Archive>
inline void serialize(Archive &a, cryptonote::account_public_address &x, const boost::serialization::version_type ver)
{
a & x.m_spend_public_key;
a & x.m_view_public_key;
}
}
}
| [
"thaer.khawaja@gmail.com"
] | thaer.khawaja@gmail.com |
04344e22ee6dfa3d3a1605637cd7e97e86fa3b05 | b8487f927d9fb3fa5529ad3686535714c687dd50 | /include/hermes/Support/Algorithms.h | 1f6f8ca079c02cda355406d04d45272537d27580 | [
"MIT"
] | permissive | hoangtuanhedspi/hermes | 4a1399f05924f0592c36a9d4b3fd1f804f383c14 | 02dbf3c796da4d09ec096ae1d5808dcb1b6062bf | refs/heads/master | 2020-07-12T21:21:53.781167 | 2019-08-27T22:58:17 | 2019-08-27T22:59:55 | 204,908,743 | 1 | 0 | MIT | 2019-08-28T17:44:49 | 2019-08-28T10:44:49 | null | UTF-8 | C++ | false | false | 1,955 | h | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the LICENSE
* file in the root directory of this source tree.
*/
//===----------------------------------------------------------------------===//
/// \file
/// <algorithm> style algorithms.
//===----------------------------------------------------------------------===//
#ifndef HERMES_SUPPORT_ALGORITHMS_H
#define HERMES_SUPPORT_ALGORITHMS_H
#include <algorithm>
#include <iterator>
#include <memory>
#include <type_traits>
namespace hermes {
/// Variants of std::uninitialized_copy and std::uninitialized_copy_n that
/// properly fall to std::copy (and thereby memmove) for trivial types. This
/// works around naive implementations of std::uninitialized_copy as seen in
/// some STL versions.
template <class InputIt, class ForwardIt>
ForwardIt uninitializedCopy(InputIt start, InputIt end, ForwardIt dst) {
using SrcType = typename std::iterator_traits<InputIt>::value_type;
using DstType = typename std::iterator_traits<ForwardIt>::value_type;
if (std::is_trivial<SrcType>::value && std::is_trivial<DstType>::value)
return std::copy(start, end, dst);
return std::uninitialized_copy(start, end, dst);
}
template <class InputIt, class Size, class ForwardIt>
ForwardIt uninitializedCopyN(InputIt src, Size count, ForwardIt dst) {
using SrcType = typename std::iterator_traits<InputIt>::value_type;
using DstType = typename std::iterator_traits<ForwardIt>::value_type;
if (std::is_trivial<SrcType>::value && std::is_trivial<DstType>::value)
return std::copy_n(src, count, dst);
return std::uninitialized_copy_n(src, count, dst);
}
/// make_unique substitute that allows its use in C++11.
template <class T, class... Args>
std::unique_ptr<T> make_unique(Args &&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
} // namespace hermes
#endif // HERMES_SUPPORT_ALGORITHMS_H
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
7ecf7d048f84b312d98b644e291e72124667b2e7 | 777a75e6ed0934c193aece9de4421f8d8db01aac | /src/Providers/UNIXProviders/RoutingProtocolDomainInAS/UNIX_RoutingProtocolDomainInAS_AIX.hxx | c4ee4481bc9d6c53e9c5115138ed4c246a9b690e | [
"MIT"
] | permissive | brunolauze/openpegasus-providers-old | 20fc13958016e35dc4d87f93d1999db0eae9010a | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | refs/heads/master | 2021-01-01T20:05:44.559362 | 2014-04-30T17:50:06 | 2014-04-30T17:50:06 | 19,132,738 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 144 | hxx | #ifdef PEGASUS_OS_AIX
#ifndef __UNIX_ROUTINGPROTOCOLDOMAININAS_PRIVATE_H
#define __UNIX_ROUTINGPROTOCOLDOMAININAS_PRIVATE_H
#endif
#endif
| [
"brunolauze@msn.com"
] | brunolauze@msn.com |
ac64e36a3da29e602380666d97b92828b67e3c7b | 04b1803adb6653ecb7cb827c4f4aa616afacf629 | /third_party/skia/include/private/SkMutex.h | cb7ad7a767335bf4ccd9ca715b5fbeb59a8956ed | [
"BSD-3-Clause",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0"
] | permissive | Samsung/Castanets | 240d9338e097b75b3f669604315b06f7cf129d64 | 4896f732fc747dfdcfcbac3d442f2d2d42df264a | refs/heads/castanets_76_dev | 2023-08-31T09:01:04.744346 | 2021-07-30T04:56:25 | 2021-08-11T05:45:21 | 125,484,161 | 58 | 49 | BSD-3-Clause | 2022-10-16T19:31:26 | 2018-03-16T08:07:37 | null | UTF-8 | C++ | false | false | 2,500 | h | /*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkMutex_DEFINED
#define SkMutex_DEFINED
#include "include/core/SkTypes.h"
#include "include/private/SkMacros.h"
#include "include/private/SkSemaphore.h"
#include "include/private/SkThreadAnnotations.h"
#include "include/private/SkThreadID.h"
#define SK_DECLARE_STATIC_MUTEX(name) static SkBaseMutex name;
class SkBaseMutex {
public:
constexpr SkBaseMutex() = default;
void acquire() {
fSemaphore.wait();
SkDEBUGCODE(fOwner = SkGetThreadID();)
}
void release() {
this->assertHeld();
SkDEBUGCODE(fOwner = kIllegalThreadID;)
fSemaphore.signal();
}
void assertHeld() {
SkASSERT(fOwner == SkGetThreadID());
}
protected:
SkBaseSemaphore fSemaphore{1};
SkDEBUGCODE(SkThreadID fOwner{kIllegalThreadID};)
};
class SK_CAPABILITY("mutex") SkMutex {
public:
constexpr SkMutex() = default;
void acquire() SK_ACQUIRE() {
fSemaphore.wait();
SkDEBUGCODE(fOwner = SkGetThreadID();)
}
void release() SK_RELEASE_CAPABILITY() {
this->assertHeld();
SkDEBUGCODE(fOwner = kIllegalThreadID;)
fSemaphore.signal();
}
void assertHeld() SK_ASSERT_CAPABILITY(this) {
SkASSERT(fOwner == SkGetThreadID());
}
private:
SkSemaphore fSemaphore{1};
SkDEBUGCODE(SkThreadID fOwner{kIllegalThreadID};)
};
class SkAutoMutexAcquire {
public:
template <typename T>
SkAutoMutexAcquire(T* mutex) : fMutex(mutex) {
if (mutex) {
mutex->acquire();
}
fRelease = [](void* mutex) { ((T*)mutex)->release(); };
}
template <typename T>
SkAutoMutexAcquire(T& mutex) : SkAutoMutexAcquire(&mutex) {}
~SkAutoMutexAcquire() { this->release(); }
void release() {
if (fMutex) {
fRelease(fMutex);
}
fMutex = nullptr;
}
private:
void* fMutex;
void (*fRelease)(void*);
};
#define SkAutoMutexAcquire(...) SK_REQUIRE_LOCAL_VAR(SkAutoMutexAcquire)
class SK_SCOPED_CAPABILITY SkAutoMutexExclusive {
public:
SkAutoMutexExclusive(SkMutex& mutex) SK_ACQUIRE(mutex) : fMutex(mutex) { fMutex.acquire(); }
~SkAutoMutexExclusive() SK_RELEASE_CAPABILITY() { fMutex.release(); }
private:
SkMutex& fMutex;
};
#define SkAutoMutexExclusive(...) SK_REQUIRE_LOCAL_VAR(SkAutoMutexExclusive)
#endif//SkMutex_DEFINED
| [
"42931768+uzair-jaleel@users.noreply.github.com"
] | 42931768+uzair-jaleel@users.noreply.github.com |
c0888dc20c50991417bd06ff917dba83142b297d | 425963de819e446a75441ff901adbfe5f1c5dea6 | /extensions/browser/api/system_power_source/system_power_source_api_unittest.cc | e08502c467983f2772e1cbc7db2698815175ad06 | [
"BSD-3-Clause"
] | permissive | Igalia/chromium | 06590680bcc074cf191979c496d84888dbb54df6 | 261db3a6f6a490742786cf841afa92e02a53b33f | refs/heads/ozone-wayland-dev | 2022-12-06T16:31:09.335901 | 2019-12-06T21:11:21 | 2019-12-06T21:11:21 | 85,595,633 | 123 | 25 | NOASSERTION | 2019-02-05T08:04:47 | 2017-03-20T15:45:36 | null | UTF-8 | C++ | false | false | 13,980 | cc | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <limits>
#include "base/bind.h"
#include "chromeos/dbus/power/fake_power_manager_client.h"
#include "extensions/browser/api/system_power_source/system_power_source_api.h"
#include "extensions/browser/api_test_utils.h"
#include "extensions/browser/api_unittest.h"
#include "extensions/browser/event_router.h"
#include "extensions/browser/event_router_factory.h"
#include "extensions/common/api/system_power_source.h"
#include "extensions/common/extension_builder.h"
using extensions::api::system_power_source::PowerSourceInfo;
using extensions::api_test_utils::RunFunctionAndReturnSingleResult;
namespace power_source_api = extensions::api::system_power_source;
namespace extensions {
namespace {
class SystemPowerSourceApiUnitTest : public ApiUnitTest {
public:
SystemPowerSourceApiUnitTest() = default;
~SystemPowerSourceApiUnitTest() override = default;
void SetUp() override {
ApiUnitTest::SetUp();
chromeos::PowerManagerClient::Initialize();
}
void TearDown() override {
chromeos::PowerManagerClient::Shutdown();
ApiUnitTest::TearDown();
}
std::unique_ptr<base::Value> RunGetPowerSourceInfoFunction() {
scoped_refptr<SystemPowerSourceGetPowerSourceInfoFunction>
get_power_source_info_function(
new SystemPowerSourceGetPowerSourceInfoFunction());
get_power_source_info_function->set_extension(extension());
get_power_source_info_function->set_has_callback(true);
return RunFunctionAndReturnSingleResult(
get_power_source_info_function.get(), "[]", browser_context());
}
std::unique_ptr<base::Value> RunRequestStatusUpdateFunction() {
scoped_refptr<SystemPowerSourceRequestStatusUpdateFunction>
request_status_update_function(
new SystemPowerSourceRequestStatusUpdateFunction());
request_status_update_function->set_extension(extension());
return RunFunctionAndReturnSingleResult(
request_status_update_function.get(), "[]", browser_context());
}
chromeos::FakePowerManagerClient* power_manager_client() {
return chromeos::FakePowerManagerClient::Get();
}
private:
DISALLOW_COPY_AND_ASSIGN(SystemPowerSourceApiUnitTest);
};
class TestEventRouter : public EventRouter {
public:
explicit TestEventRouter(content::BrowserContext* context)
: EventRouter(context, nullptr) {}
~TestEventRouter() override = default;
void BroadcastEvent(std::unique_ptr<Event> event) override {
if (event->event_name !=
api::system_power_source::OnPowerChanged::kEventName) {
return;
}
ASSERT_TRUE(event->event_args);
ASSERT_EQ(1u, event->event_args->GetList().size());
power_source_info_.emplace_back(event->event_args->GetList()[0].Clone());
}
const std::vector<base::Value>& power_source_info() const {
return power_source_info_;
}
void clear_power_source_info() { power_source_info_.clear(); }
private:
std::vector<base::Value> power_source_info_;
DISALLOW_COPY_AND_ASSIGN(TestEventRouter);
};
std::unique_ptr<KeyedService> TestEventRouterFactoryFunction(
content::BrowserContext* context) {
return std::make_unique<TestEventRouter>(context);
}
power_manager::PowerSupplyProperties MakePowerSupplyProperties(
const base::Optional<std::string>& external_power_source_id,
const std::vector<power_manager::PowerSupplyProperties_PowerSource>&
power_sources) {
power_manager::PowerSupplyProperties props;
if (external_power_source_id)
props.set_external_power_source_id(*external_power_source_id);
for (const auto& power_source : power_sources)
*props.add_available_external_power_source() = power_source;
return props;
}
power_manager::PowerSupplyProperties_PowerSource MakePowerSource(
const std::string& id,
power_manager::PowerSupplyProperties_PowerSource_Type type,
double max_power) {
power_manager::PowerSupplyProperties_PowerSource power_source;
power_source.set_id(id);
power_source.set_type(type);
power_source.set_max_power(max_power);
return power_source;
}
} // namespace
// Barrel jack connected
TEST_F(SystemPowerSourceApiUnitTest, GetPowerSourceAc) {
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"AC",
{MakePowerSource(
"AC", power_manager::PowerSupplyProperties_PowerSource_Type_MAINS,
0)}));
std::unique_ptr<base::Value> result = RunGetPowerSourceInfoFunction();
ASSERT_TRUE(result);
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "mains")
.Set("active", true)
.Build())
.Build();
EXPECT_EQ(*expected_result, *result);
}
// USB-C PD charger connected
TEST_F(SystemPowerSourceApiUnitTest, GetPowerSourceUsb) {
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"CROS_USB_PD_CHARGER0",
{{MakePowerSource(
"CROS_USB_PD_CHARGER0",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C, 60)}}));
std::unique_ptr<base::Value> result = RunGetPowerSourceInfoFunction();
ASSERT_TRUE(result);
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 60.0)
.Set("active", true)
.Build())
.Build();
EXPECT_EQ(*expected_result, *result);
}
// Barrel Jack + USB-C PD charger connected; Barrel Jack active
TEST_F(SystemPowerSourceApiUnitTest, GetPowerSourceAcActiveAndUsbInactive) {
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"AC",
{{MakePowerSource(
"AC", power_manager::PowerSupplyProperties_PowerSource_Type_MAINS,
0),
MakePowerSource(
"CROS_USB_PD_CHARGER0",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C,
60)}}));
std::unique_ptr<base::Value> result = RunGetPowerSourceInfoFunction();
ASSERT_TRUE(result);
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "mains")
.Set("active", true)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 60.0)
.Set("active", false)
.Build())
.Build();
EXPECT_EQ(*expected_result, *result);
}
// Barrel Jack + USB-C PD charger connected; USB-C charger active
TEST_F(SystemPowerSourceApiUnitTest, GetPowerSourceAcInactiveAndUsbActive) {
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"CROS_USB_PD_CHARGER0",
{{MakePowerSource(
"AC", power_manager::PowerSupplyProperties_PowerSource_Type_MAINS,
0),
MakePowerSource(
"CROS_USB_PD_CHARGER0",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C,
60)}}));
std::unique_ptr<base::Value> result = RunGetPowerSourceInfoFunction();
ASSERT_TRUE(result);
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "mains")
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 60.0)
.Set("active", true)
.Build())
.Build();
EXPECT_EQ(*expected_result, *result);
}
// Barrel Jack + USB-C PD charger connected; neither active
TEST_F(SystemPowerSourceApiUnitTest, GetPowerSourceNoneActive) {
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
base::nullopt,
{{MakePowerSource(
"AC", power_manager::PowerSupplyProperties_PowerSource_Type_MAINS,
0),
MakePowerSource(
"CROS_USB_PD_CHARGER0",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C,
60)}}));
std::unique_ptr<base::Value> result = RunGetPowerSourceInfoFunction();
ASSERT_TRUE(result);
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "mains")
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 60.0)
.Set("active", false)
.Build())
.Build();
EXPECT_EQ(*expected_result, *result);
}
// Connected USB chargers with fractional max power gets rounded down to
// two significant digits (for privacy reasons, to reduce the risk of
// finger-printing). Chargers with a max power that is not a normal value
// larger than zero are reported as not having a max power value.
TEST_F(SystemPowerSourceApiUnitTest, GetPowerSourceRounding) {
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"CROS_USB_PD_CHARGER0",
{{MakePowerSource(
"CROS_USB_PD_CHARGER0",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C, 111.0),
MakePowerSource(
"CROS_USB_PD_CHARGER1",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C, 11.1),
MakePowerSource(
"CROS_USB_PD_CHARGER2",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C, 1.11),
MakePowerSource(
"CROS_USB_PD_CHARGER3",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C, 0.111),
MakePowerSource(
"CROS_USB_PD_CHARGER4",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C, -1),
MakePowerSource(
"CROS_USB_PD_CHARGER5",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C,
std::nan("")),
MakePowerSource(
"CROS_USB_PD_CHARGER6",
power_manager::PowerSupplyProperties_PowerSource_Type_USB_C,
std::numeric_limits<double>::infinity())}}));
std::unique_ptr<base::Value> result = RunGetPowerSourceInfoFunction();
ASSERT_TRUE(result);
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 110.0)
.Set("active", true)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 11.0)
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 1.1)
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("maxPower", 0.11)
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("active", false)
.Build())
.Append(DictionaryBuilder()
.Set("type", "usb")
.Set("active", false)
.Build())
.Build();
EXPECT_EQ(*expected_result, *result);
}
TEST_F(SystemPowerSourceApiUnitTest, OnPowerChangedEvent) {
TestEventRouter* event_router = static_cast<TestEventRouter*>(
EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
browser_context(),
base::BindRepeating(&TestEventRouterFactoryFunction)));
SystemPowerSourceAPI system_power_source_api(browser_context());
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"AC",
{MakePowerSource(
"AC", power_manager::PowerSupplyProperties_PowerSource_Type_MAINS,
0)}));
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "mains")
.Set("active", true)
.Build())
.Build();
ASSERT_EQ(1U, event_router->power_source_info().size());
EXPECT_EQ(*expected_result, event_router->power_source_info()[0]);
}
TEST_F(SystemPowerSourceApiUnitTest, RequestStatusUpdate) {
TestEventRouter* event_router = static_cast<TestEventRouter*>(
EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
browser_context(),
base::BindRepeating(&TestEventRouterFactoryFunction)));
SystemPowerSourceAPI system_power_source_api(browser_context());
power_manager_client()->UpdatePowerProperties(MakePowerSupplyProperties(
"AC",
{MakePowerSource(
"AC", power_manager::PowerSupplyProperties_PowerSource_Type_MAINS,
0)}));
event_router->clear_power_source_info();
RunRequestStatusUpdateFunction();
base::RunLoop().RunUntilIdle();
std::unique_ptr<base::Value> expected_result =
ListBuilder()
.Append(DictionaryBuilder()
.Set("type", "mains")
.Set("active", true)
.Build())
.Build();
ASSERT_EQ(1U, event_router->power_source_info().size());
EXPECT_EQ(*expected_result, event_router->power_source_info()[0]);
}
} // namespace extensions
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
fa39f8410d49009eb9235b949fa12165857edc4b | 1a060f9a60aed8e7e276c77349b8c31af3033cfe | /cca/ga_cca_classic/DistArrayTemplFactoryPort.h | 23c0ec8b5da5ed745176506063cb71b535e2d60a | [
"BSD-3-Clause",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | GlobalArrays/ga | 4682d0fa31316d4f0ba0a387761a7283ebaabfd5 | 56087b52459e311e49fc05d9708329a39b776549 | refs/heads/master | 2023-09-04T04:18:20.615897 | 2023-07-14T17:30:44 | 2023-07-14T17:30:44 | 82,336,637 | 97 | 57 | NOASSERTION | 2023-08-05T00:47:34 | 2017-02-17T20:48:30 | C | UTF-8 | C++ | false | false | 2,057 | h | #ifndef DistArrayTemplFactoryPort_h_seen
#define DistArrayTemplFactoryPort_h_seen
#include <string>
#include "DistArrayTemplate.h"
namespace classic {
namespace gov {
namespace cca {
/** An interface for creating distributed array template
descriptors.
$Id: DistArrayTemplFactoryPort.h,v 1.1 2003-08-01 00:41:54 manoj Exp $
This interface allows users to create, clone, and destroy
descriptors for array distribution templates.
*/
class DistArrayTemplFactoryPort: public virtual ::classic::gov::cca::Port {
public:
/** Return an uninitialized template object.
@param name (in) Name associated with this template. This
is a "forced convenience" for the user to allow intelligible
error messages, etc.
@returns a reference to an uninitialized template object.
*/
virtual DistArrayTemplate* createTemplate(std::string name) = 0;
/** Return a template object initialized with the contents of
another, but not frozen against modification.
@param original (in) Template from which to initialize new
template.
@param cloneName (in) Name associated with this template.
This is a "forced convenience" for the user to allow
intelligible error messages, etc.
@returns a reference to an initialized but not frozen
template object.
*/
virtual DistArrayTemplate* cloneTemplate(DistArrayTemplate * original, std::string cloneName) = 0;
/** Destroy an existing template.
@param victim (in) Template to be destroyed.
@retval 0 Success
@retval -1 Template not created by this factory
@retval -2 Template has already been destroyed
@retval -3 Concrete class of template is not is not the type
produced by this factory.
@notes Should throw exceptions instead of returning an int.
*/
virtual int destroyTemplate(DistArrayTemplate * & victim) = 0;
}; // DistArrayTemplFactoryPort
} // namespace cca
} // namespace gov
} // namespace classic
#endif // DistArrayTemplFactoryPort_h_seen
| [
"hpctools@googlegroups.com"
] | hpctools@googlegroups.com |
7f89552adc6076e4cc04fba004e655f3f8468d1b | 0c5b4bf59afb950f6547a0606520f61a645331ea | /src/components/LabelComponent.cpp | b559fffe07ae49debec2e3464ef3dce15ad27ff2 | [] | no_license | JeanPhilippeKernel/T_ENGINE | ca53a990a7e18951e28e1aa4740826b3aebdb596 | 518ed4dac3e7948315e1258dc78745bf439ce4e2 | refs/heads/master | 2022-07-10T19:48:17.945037 | 2020-05-15T23:16:19 | 2020-05-15T23:16:19 | 264,318,791 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,490 | cpp | #pragma once
#include "LabelComponent.h"
#include "../Engine.h"
#include "../FontManager.h"
namespace T_Engine
{
namespace Component
{
LabelComponent::LabelComponent(const char* asset_key, const char* label,
std::uint8_t red, std::uint8_t green, std::uint8_t blue
) : m_label(label)
{
m_font = Engine::AssetManager->GetFont(asset_key);
m_color = { red, green, blue, SDL_ALPHA_OPAQUE };
}
void LabelComponent::Initialize()
{
if (Owner_ptr && Owner_ptr->HasComponent<TransformComponent>())
{
m_tranform_component = Owner_ptr->GetComponent<TransformComponent>();
m_destination.x = m_tranform_component->position().x;
m_destination.y = m_tranform_component->position().y;
m_destination.w = m_tranform_component->width();
m_destination.h = m_tranform_component->height();
}
}
void LabelComponent::Update(float delta_time)
{
m_destination.x = m_tranform_component->position().x;
m_destination.y = m_tranform_component->position().y;
m_destination.w = m_tranform_component->width();
m_destination.h = m_tranform_component->height();
}
void LabelComponent::Render()
{
auto surface = TTF_RenderText_Blended(const_cast<TTF_Font*>(m_font), m_label.c_str(), m_color);
if (surface)
{
auto texture = SDL_CreateTextureFromSurface(Engine::Renderer, surface);
FontManager::RenderFont(Engine::Renderer, texture, &m_destination);
SDL_FreeSurface(surface);
SDL_DestroyTexture(texture);
}
}
}
} | [
"jeanphilippe02666592@outlook.fr"
] | jeanphilippe02666592@outlook.fr |
b07e3027abd55a0424bb21eaa006f6cd8fd7cc50 | a7e92a5ceec98bc4c0f087002565ceeca863f2e5 | /ch2_linked_lists/test_linked_list.cc | b19f5574da4813ad94664aba05c3bd828fa1651e | [] | no_license | kmad1729/cci | b03190037517f30ba8315fa7af24cacfb526978c | a84a4a7ddb9a711d15af8ea5742291dd076241dd | refs/heads/master | 2021-01-17T12:57:38.052539 | 2016-06-23T05:38:43 | 2016-06-23T05:38:43 | 58,879,889 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 504 | cc | #define _DEBUG 1
#include "linked_list.h"
#include <iostream>
#include <string>
using namespace std;
int main()
{
string delim = string(20, '#') + '\n';
LinkedList<char> ll;
ll.insert_node('s');
ll.insert_node('t');
ll.insert_node('a');
ll.insert_node('r');
ll.insert_node('e');
cout << "linked list --> " << endl;
ll.print_list();
char del = 'e';
ll.delete_node(del);
del = 'f';
ll.delete_node(del);
del = 'a';
ll.delete_node(del);
}
| [
"kashyapmaduri@outlook.com"
] | kashyapmaduri@outlook.com |
a499324844bfd5f03f2554ba8739b37fdff032bf | 00acf85b828f06ef89c5df3d263be3e451e20ff3 | /src/tests/main.cc | 298ee37c49cda38a4db80c3cbb0e25144d4e855f | [] | no_license | afett/format | 725c63f74adf6dab03a3745340e49b56e121ee2b | b600d447476e700a6049fcb7ecd1d8753ff674ce | refs/heads/master | 2023-04-07T05:49:14.438516 | 2021-04-05T09:53:05 | 2021-04-05T09:58:47 | 354,789,160 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,310 | cc | #include <cppunit/BriefTestProgressListener.h>
#include <cppunit/TestResult.h>
#include <cppunit/TextTestRunner.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/CompilerOutputter.h>
#include <cstdlib>
#include <unistd.h>
namespace {
void printTestTree(CppUnit::Test const* root)
{
std::cerr << root->getName() << "\n";
for (int i(0); i < root->getChildTestCount(); ++i) {
printTestTree(root->getChildTestAt(i));
}
}
}
int main(int argc, char *argv[])
{
auto list{false};
std::string testname;
int opt;
while ((opt = getopt(argc, argv, "lt:")) != -1) {
switch (opt) {
case 'l':
list = true;
break;
case 't':
testname = optarg;
break;
default: /* '?' */
std::cerr << "Usage:" << argv[0] << " [-t name] [-l]\n";
return EXIT_FAILURE;
}
}
CppUnit::TestFactoryRegistry & registry(
CppUnit::TestFactoryRegistry::getRegistry());
CppUnit::Test *test(registry.makeTest());
if (list) {
printTestTree(test);
return EXIT_SUCCESS;
}
CppUnit::TextTestRunner runner;
runner.addTest(test);
CppUnit::BriefTestProgressListener progress;
runner.eventManager().addListener(&progress);
runner.setOutputter(new CppUnit::CompilerOutputter(
&runner.result(), std::cerr, "%p:%l:"));
return runner.run(testname) ? EXIT_SUCCESS : EXIT_FAILURE;
}
| [
"a.fett@gmx.de"
] | a.fett@gmx.de |
d341e0137b144b2ad787c69c9f5338a555ac2d9f | 0238d82510bd608dfa08d48dd0a2c8f296a9edbe | /高校教材管理系统_MFC_mysql/oracle_homework5/del_book.h | 82b4429aee1b1edaa41ef3b95b39897740ca02f4 | [] | no_license | cosmoszz/University-teaching-material-management-system | 30547ba69d8e5980bffde55238506a20ea002f18 | ee9a79e26db5a1a07b3fe485b082532c9b785be7 | refs/heads/master | 2021-01-01T03:57:45.602595 | 2016-06-08T09:21:41 | 2016-06-08T09:21:41 | 59,454,447 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 457 | h | #pragma once
// del_book 对话框
class del_book : public CDialogEx
{
DECLARE_DYNAMIC(del_book)
public:
del_book(CWnd* pParent = NULL); // 标准构造函数
virtual ~del_book();
// 对话框数据
enum { IDD = IDD_del_book };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
DECLARE_MESSAGE_MAP()
public:
CString infor_1;
afx_msg void OnEnChangeEdit1();
bool isbnok = 0;
afx_msg void OnBnClickedOk();
};
| [
"151918328142@163.com"
] | 151918328142@163.com |
dc9f7995d4c1f893e3726f263b8c0e7e49f4097c | c3e1fce7a720bb66a3814123727b6f835b54c8fd | /src/voglcore/vogl_threading_win32.h | 9848739b0cac2ac7bc5b096939baa10bb8c7f8dd | [
"MIT"
] | permissive | isabella232/vogl | 6df37b32eb5c484a461b50eb50b75f2a95ffb733 | 172a86d9c4ee08dccbf4e342caa1ba63f1ea2b0e | refs/heads/master | 2022-04-18T21:11:14.760227 | 2014-03-14T21:55:20 | 2014-03-14T21:55:20 | 482,027,147 | 0 | 0 | MIT | 2022-04-16T02:59:09 | 2022-04-15T16:59:45 | null | UTF-8 | C++ | false | false | 12,722 | h | /**************************************************************************
*
* Copyright 2013-2014 RAD Game Tools and Valve Software
* Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
* All Rights Reserved.
*
* 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.
*
**************************************************************************/
// File: vogl_win32_threading.h
#pragma once
#include "vogl_core.h"
#include "vogl_atomics.h"
#if VOGL_NO_ATOMICS
#error No atomic operations defined in vogl_platform.h!
#endif
namespace vogl
{
// g_number_of_processors defaults to 1. Will be higher on multicore machines.
extern uint g_number_of_processors;
void vogl_threading_init();
typedef uint64_t vogl_thread_id_t;
vogl_thread_id_t vogl_get_current_thread_id();
void vogl_sleep(unsigned int milliseconds);
uint vogl_get_max_helper_threads();
class mutex
{
VOGL_NO_COPY_OR_ASSIGNMENT_OP(mutex);
public:
mutex(unsigned int spin_count = 0);
~mutex();
void lock();
void unlock();
void set_spin_count(unsigned int count);
private:
int m_buf[12];
#ifdef VOGL_BUILD_DEBUG
unsigned int m_lock_count;
#endif
};
class scoped_mutex
{
scoped_mutex(const scoped_mutex &);
scoped_mutex &operator=(const scoped_mutex &);
public:
inline scoped_mutex(mutex &m)
: m_mutex(m)
{
m_mutex.lock();
}
inline ~scoped_mutex()
{
m_mutex.unlock();
}
private:
mutex &m_mutex;
};
// Simple non-recursive spinlock.
class spinlock
{
VOGL_NO_COPY_OR_ASSIGNMENT_OP(spinlock);
public:
inline spinlock()
: m_flag(0)
{
}
void lock(uint32 max_spins = 4096, bool yielding = true);
inline void lock_no_barrier(uint32 max_spins = 4096, bool yielding = true)
{
lock(max_spins, yielding);
}
void unlock();
inline void unlock_no_barrier()
{
m_flag = VOGL_FALSE;
}
private:
volatile int32 m_flag;
};
class scoped_spinlock
{
scoped_spinlock(const scoped_spinlock &);
scoped_spinlock &operator=(const scoped_spinlock &);
public:
inline scoped_spinlock(spinlock &lock)
: m_lock(lock)
{
m_lock.lock();
}
inline ~scoped_spinlock()
{
m_lock.unlock();
}
private:
spinlock &m_lock;
};
class semaphore
{
VOGL_NO_COPY_OR_ASSIGNMENT_OP(semaphore);
public:
// TODO: Change to uint32
semaphore(int32 initialCount, int32 maximumCount, const char *pName = NULL);
~semaphore();
inline HANDLE get_handle(void) const
{
return m_handle;
}
void release(int32 releaseCount = 1, int32 *pPreviousCount = NULL);
bool try_release(int32 releaseCount = 1, int32 *pPreviousCount = NULL);
bool wait(uint32 milliseconds = cUINT32_MAX);
private:
HANDLE m_handle;
};
template <typename T>
class tsstack
{
VOGL_NO_COPY_OR_ASSIGNMENT_OP(tsstack);
public:
inline tsstack(bool use_freelist = true)
: m_use_freelist(use_freelist)
{
VOGL_VERIFY(((ptr_bits_t) this & (VOGL_GET_ALIGNMENT(tsstack) - 1)) == 0);
InitializeSListHead(&m_stack_head);
InitializeSListHead(&m_freelist_head);
}
inline ~tsstack()
{
clear();
}
inline void clear()
{
for (;;)
{
node *pNode = (node *)InterlockedPopEntrySList(&m_stack_head);
if (!pNode)
break;
VOGL_MEMORY_IMPORT_BARRIER
helpers::destruct(&pNode->m_obj);
vogl_free(pNode);
}
flush_freelist();
}
inline void flush_freelist()
{
if (!m_use_freelist)
return;
for (;;)
{
node *pNode = (node *)InterlockedPopEntrySList(&m_freelist_head);
if (!pNode)
break;
VOGL_MEMORY_IMPORT_BARRIER
vogl_free(pNode);
}
}
inline bool try_push(const T &obj)
{
node *pNode = alloc_node();
if (!pNode)
return false;
helpers::construct(&pNode->m_obj, obj);
VOGL_MEMORY_EXPORT_BARRIER
InterlockedPushEntrySList(&m_stack_head, &pNode->m_slist_entry);
return true;
}
inline bool pop(T &obj)
{
node *pNode = (node *)InterlockedPopEntrySList(&m_stack_head);
if (!pNode)
return false;
VOGL_MEMORY_IMPORT_BARRIER
obj = pNode->m_obj;
helpers::destruct(&pNode->m_obj);
free_node(pNode);
return true;
}
private:
SLIST_HEADER m_stack_head;
SLIST_HEADER m_freelist_head;
struct node
{
SLIST_ENTRY m_slist_entry;
T m_obj;
};
bool m_use_freelist;
inline node *alloc_node()
{
node *pNode = m_use_freelist ? (node *)InterlockedPopEntrySList(&m_freelist_head) : NULL;
if (!pNode)
pNode = (node *)vogl_malloc(sizeof(node));
return pNode;
}
inline void free_node(node *pNode)
{
if (m_use_freelist)
InterlockedPushEntrySList(&m_freelist_head, &pNode->m_slist_entry);
else
vogl_free(pNode);
}
};
// Simple multithreaded task pool. This class assumes a single global thread will be issuing tasks and joining.
class task_pool
{
VOGL_NO_COPY_OR_ASSIGNMENT_OP(task_pool);
public:
task_pool();
task_pool(uint num_threads);
~task_pool();
enum
{
cMaxThreads = 16
};
bool init(uint num_threads);
void deinit();
inline uint get_num_threads() const
{
return m_num_threads;
}
inline uint32 get_num_outstanding_tasks() const
{
return m_total_submitted_tasks - m_total_completed_tasks;
}
// C-style task callback
typedef void (*task_callback_func)(uint64_t data, void *pData_ptr);
bool queue_task(task_callback_func pFunc, uint64_t data = 0, void *pData_ptr = NULL);
class executable_task
{
public:
virtual void execute_task(uint64_t data, void *pData_ptr) = 0;
};
// It's the caller's responsibility to delete pObj within the execute_task() method, if needed!
bool queue_task(executable_task *pObj, uint64_t data = 0, void *pData_ptr = NULL);
template <typename S, typename T>
inline bool queue_object_task(S *pObject, T pObject_method, uint64_t data = 0, void *pData_ptr = NULL);
template <typename S, typename T>
inline bool queue_multiple_object_tasks(S *pObject, T pObject_method, uint64_t first_data, uint num_tasks, void *pData_ptr = NULL);
// Waits for all outstanding tasks (if any) to complete.
// The calling thread will steal any outstanding tasks from worker threads, if possible.
void join();
private:
struct task
{
//inline task() : m_data(0), m_pData_ptr(NULL), m_pObj(NULL), m_flags(0) { }
uint64_t m_data;
void *m_pData_ptr;
union
{
task_callback_func m_callback;
executable_task *m_pObj;
};
uint m_flags;
};
typedef tsstack<task> ts_task_stack_t;
ts_task_stack_t *m_pTask_stack;
uint m_num_threads;
HANDLE m_threads[cMaxThreads];
// Signalled whenever a task is queued up.
semaphore m_tasks_available;
// Signalled when all outstanding tasks are completed.
semaphore m_all_tasks_completed;
enum task_flags
{
cTaskFlagObject = 1
};
volatile atomic32_t m_total_submitted_tasks;
volatile atomic32_t m_total_completed_tasks;
volatile atomic32_t m_exit_flag;
void process_task(task &tsk);
static unsigned __stdcall thread_func(void *pContext);
};
enum object_task_flags
{
cObjectTaskFlagDefault = 0,
cObjectTaskFlagDeleteAfterExecution = 1
};
template <typename T>
class object_task : public task_pool::executable_task
{
public:
object_task(uint flags = cObjectTaskFlagDefault)
: m_pObject(NULL),
m_pMethod(NULL),
m_flags(flags)
{
}
typedef void (T::*object_method_ptr)(uint64_t data, void *pData_ptr);
object_task(T *pObject, object_method_ptr pMethod, uint flags = cObjectTaskFlagDefault)
: m_pObject(pObject),
m_pMethod(pMethod),
m_flags(flags)
{
VOGL_ASSERT(pObject && pMethod);
}
void init(T *pObject, object_method_ptr pMethod, uint flags = cObjectTaskFlagDefault)
{
VOGL_ASSERT(pObject && pMethod);
m_pObject = pObject;
m_pMethod = pMethod;
m_flags = flags;
}
T *get_object() const
{
return m_pObject;
}
object_method_ptr get_method() const
{
return m_pMethod;
}
virtual void execute_task(uint64_t data, void *pData_ptr)
{
(m_pObject->*m_pMethod)(data, pData_ptr);
if (m_flags & cObjectTaskFlagDeleteAfterExecution)
vogl_delete(this);
}
protected:
T *m_pObject;
object_method_ptr m_pMethod;
uint m_flags;
};
template <typename S, typename T>
inline bool task_pool::queue_object_task(S *pObject, T pObject_method, uint64_t data, void *pData_ptr)
{
object_task<S> *pTask = vogl_new<object_task<S> >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution);
if (!pTask)
return false;
return queue_task(pTask, data, pData_ptr);
}
template <typename S, typename T>
inline bool task_pool::queue_multiple_object_tasks(S *pObject, T pObject_method, uint64_t first_data, uint num_tasks, void *pData_ptr)
{
VOGL_ASSERT(pObject);
VOGL_ASSERT(num_tasks);
if (!num_tasks)
return true;
bool status = true;
uint i;
for (i = 0; i < num_tasks; i++)
{
task tsk;
tsk.m_pObj = vogl_new<object_task<S> >(pObject, pObject_method, cObjectTaskFlagDeleteAfterExecution);
if (!tsk.m_pObj)
{
status = false;
break;
}
tsk.m_data = first_data + i;
tsk.m_pData_ptr = pData_ptr;
tsk.m_flags = cTaskFlagObject;
atomic_increment32(&m_total_submitted_tasks);
if (!m_pTask_stack->try_push(tsk))
{
atomic_increment32(&m_total_completed_tasks);
status = false;
break;
}
}
if (i)
{
m_tasks_available.release(i);
}
return status;
}
} // namespace vogl
| [
"mikesart@gmail.com"
] | mikesart@gmail.com |
9e699f6ffb365e9300ae5307ed3d6a20aa49e027 | ae5751fb6a6907745456d617e88990842ea16c73 | /Seperation.cpp | f05e29b59a8fa796fad201b5c3bb6b241900e5e1 | [] | no_license | Chillex/ai-platoon | dc211cd8d61829ca885c9c72219c00251a99cbde | 458c4db53a6f85c3587ac460bdd89976bc508f47 | refs/heads/master | 2021-03-22T00:28:16.906741 | 2016-11-20T20:56:44 | 2016-11-20T20:56:44 | 72,350,556 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,152 | cpp | #include "Seperation.h"
#include "SteeringStruct.h"
#include "Agent.h"
#include "World.h"
#include <iostream>
Seperation::Seperation()
{
}
Seperation::~Seperation()
{
}
Steering Seperation::GetSteering(Agent& agent, World& world)
{
Steering steering;
steering.SetZero();
steering.linear = SeperationVelocity(agent, world.GetAgents());
return steering;
}
glm::vec2 Seperation::SeperationVelocity(const Agent& agent, const std::vector<Agent*>& worldAgents) const
{
glm::vec2 velocity(0.0f);
int neighbours = 0;
for (std::vector<Agent*>::const_iterator it = worldAgents.begin(); it != worldAgents.end(); ++it)
{
const Agent& neighbour = *(*it);
if(&neighbour == &agent || neighbour.team != agent.team)
continue;
glm::vec2 direction = agent.position - neighbour.position;
float distance = glm::length(direction);
if(distance < agent.sizeRadius * 2)
{
float strength = agent.maxLinearVelocity * (agent.sizeRadius * 2 - distance) / agent.sizeRadius * 2;
//float strength = std::min(5.0f / (distance * distance), agent.maxLinearVelocity);
velocity += strength * glm::normalize(direction);
}
}
return velocity;
}
| [
"if14b069@technikum-wien.at"
] | if14b069@technikum-wien.at |
9af5ae420a2499970179c12408bb14d939ca3095 | c085162d0b002b413e6327000ac417ad0f4439bf | /include/NetClient/NetClientOp.hpp | d9f649c3644c951c5f2b95c27fc5ac943a1f57b2 | [] | no_license | bin432/_Common | 4fc7c96cbb2e23464e809a8df2536c1b9d65e96f | 1dfda050813232d8720189c2dc987ebdea7846dd | refs/heads/master | 2020-03-28T07:22:21.341246 | 2019-04-13T13:10:59 | 2019-04-13T13:10:59 | 147,896,769 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 3,804 | hpp | /************************************************************************/
// 对 NetClientDll的一些封装
/************************************************************************/
#ifndef _NETCLIENTOP_H
#define _NETCLIENTOP_H
#pragma once
#include "NetClientDll.h"
#ifdef _WIN64
#if _DEBUG
#pragma comment(lib, "NetClientDll64_d.lib")
#else
#pragma comment(lib, "NetClientDll64.lib")
#endif
#else
#if _DEBUG
#pragma comment(lib, "NetClientDll_d.lib")
#else
#pragma comment(lib, "NetClientDll.lib")
#endif
#endif
// Http 响应 封装 IResponse
class Response
{
protected:
NetClient::IResponse* m_resp;
public:
Response(NetClient::IResponse* resp)
: m_resp(resp)
{
}
~Response()
{
if(nullptr != m_resp)
{
NetClient::fnDeleteObject(m_resp);
m_resp = nullptr;
}
}
public:
bool IsVaild()
{
return nullptr != m_resp;
}
int GetStatusCode()
{
return m_resp->GetStatusCode();
}
const char* GetStatusText()
{
return m_resp->GetStatusText();
}
const char* GetHeader(const char* lpKey)
{
return m_resp->GetHeader(lpKey);
}
const char* GetBody(int* pLen = nullptr)
{
return m_resp->GetBody(pLen);
}
};
class RespReader
{
protected:
NetClient::IRespReader* m_resp;
public:
RespReader(NetClient::IRespReader* resp)
: m_resp(resp)
{
}
~RespReader()
{
if (nullptr != m_resp)
{
NetClient::fnDeleteObject(m_resp);
m_resp = nullptr;
}
}
public:
bool IsVaild()
{
return nullptr != m_resp;
}
int GetStatusCode()
{
return m_resp->GetStatusCode();
}
const char* GetStatusText()
{
return m_resp->GetStatusText();
}
const char* GetHeader(const char* lpKey)
{
return m_resp->GetHeader(lpKey);
}
int Read(char* pBuf, int nRead)
{
return m_resp->Read(pBuf, nRead);
}
};
//
class HttpStream
{
protected:
NetClient::IHttpClient* m_pHttpClient;
int m_nReq;
public:
HttpStream(NetClient::IHttpClient* pHttpClient)
: m_pHttpClient(pHttpClient)
{
}
~HttpStream()
{
}
int GetErrorCode(int& nPos)
{
return m_pHttpClient->GetErrorCode(nPos);
}
public:
bool Post(const char* lpPath, const char* lpHeader, unsigned int nContentLen)
{
m_nReq = m_pHttpClient->Request_Post2(lpPath, lpHeader, nContentLen);
return -1 != m_nReq;
}
int Write(const char* pData, int nLen)
{
return m_pHttpClient->SendBody(m_nReq, pData, nLen);
}
Response End()
{
auto resp = m_pHttpClient->EndRequest(m_nReq);
return Response(resp);
}
};
// http 客户端 实现 支持 多线程 也是 安全的
class NetHttpClient
{
protected:
NetClient::IHttpClient* m_pHttpClient;
public:
NetHttpClient()
: m_pHttpClient(nullptr)
{
//fnCreateCrypto(&m_ICryptFun);
}
~NetHttpClient()
{
if(nullptr != m_pHttpClient)
NetClient::fnDeleteHttpClient(m_pHttpClient);
}
bool IsValid()
{
return nullptr != m_pHttpClient;
}
int GetErrorCode(int& nPos)
{
return m_pHttpClient->GetErrorCode(nPos);
}
public:
bool Create(LPCTSTR lpIp, int nPort)
{
return NetClient::fnCreateHttpClient(&m_pHttpClient, lpIp, nPort);
}
void Reset()
{
if(nullptr != m_pHttpClient)
{
NetClient::fnDeleteHttpClient(m_pHttpClient);
m_pHttpClient = nullptr;
}
}
Response Get(const char* lpPath, const char* lpHeader)
{
NetClient::IResponse* resp = m_pHttpClient->Request_Get(lpPath, lpHeader);
return Response(resp);
}
RespReader GetFile(const char* lpPath, const char* lpHeader=nullptr)
{
NetClient::IRespReader* resp = m_pHttpClient->Request_GetFile(lpPath, lpHeader);
return RespReader(resp);
}
Response Post(const char* lpPath, const char* lpHeader, const char* pData, int nLen)
{
NetClient::IResponse* resp = m_pHttpClient->Request_Post(lpPath, lpHeader, pData, nLen);
return Response(resp);
}
HttpStream NewStream()
{
return HttpStream(m_pHttpClient);
}
};
#endif | [
"wuxingbin1204@163.com"
] | wuxingbin1204@163.com |
46489b0b99788def8847523b746fc5193f81b3f8 | 6b6b170c04cb0c4c8c03ee10790ecdbcf9c3f8b4 | /musicplayer2/playlistmodel.cpp | 084f431e911aa4b41c167d858b380b7b77851a12 | [] | no_license | apriljdai/AA-Music-Player | 22ec8cbf35e3a7909aade6f213836c352f6c7620 | e3341949954ab651986f015fccf93f67b0e6ab6d | refs/heads/master | 2020-05-20T05:58:28.688581 | 2015-01-09T08:00:43 | 2015-01-09T08:00:45 | 28,373,074 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,144 | cpp | #include "playlistmodel.h"
#include <QColor>
#include <QBrush>
#include <QMimeData>
PlaylistModel::PlaylistModel(QObject *parent)
: QAbstractTableModel(parent){
columns = 4;
m_data = QList<QHash<QString, QString> >();
curMediaIdx = -1;
finishedPlaylist = false;
u = new Util();
mode = NORMAL;
}
PlaylistModel::~PlaylistModel() {
}
int PlaylistModel::rowCount(const QModelIndex &parent) const {
return (!parent.isValid()) ? m_data.size() : 0;
}
int PlaylistModel::columnCount(const QModelIndex &parent) const {
return (!parent.isValid()) ? columns : 0;
}
QModelIndex PlaylistModel::index(int row, int column, const QModelIndex &parent) const {
return (!parent.isValid()
&& row >= 0 && row < m_data.size()
&& column >= 0 && column < columns) ?
createIndex(row, column) : QModelIndex();
}
QModelIndex PlaylistModel::parent(const QModelIndex &child) const {
Q_UNUSED(child);
return QModelIndex();
}
QVariant PlaylistModel::data(const QModelIndex &index, int role) const {
if (!index.isValid()) {
return QVariant();
}
if (index.row() >= m_data.size() || index.row() < 0) {
return QVariant();
}
if (role == Qt::DisplayRole) {
const QHash<QString, QString> h = m_data.at(index.row());
switch(index.column()) {
case 0:
// title
return h["Title"];
case 1:
// artist
return h["Artist"];
case 2:
// album
return h["Album"];
case 3:
// length
return h["Length"];
default:
return QVariant();
}
}
if (role == Qt::EditRole) {
const QHash<QString, QString> h = m_data.at(index.row());
switch(index.column()) {
case 0:
// title
return h["Title"];
case 1:
// artist
return h["Artist"];
case 2:
// album
return h["Album"];
case 3:
// length
return h["Length"];
default:
return QVariant();
}
}
return QVariant();
}
QVariant PlaylistModel::headerData(int section, Qt::Orientation orientation, int role) const {
if (role != Qt::DisplayRole) {
return QVariant();
}
if (orientation == Qt::Horizontal) {
switch (section) {
case 0:
return tr("Title");
case 1:
return tr("Artist");
case 2:
return tr("Album");
case 3:
return tr("Length");
default:
return QVariant();
}
}
return QVariant();
}
Qt::ItemFlags PlaylistModel::flags(const QModelIndex &index) const {
if (!index.isValid()) {
return Qt::ItemIsEnabled | Qt::ItemIsDropEnabled;
}
if (index.column() == 3) {
// clicking on length doesn't do anything
return QAbstractTableModel::flags(index) | Qt::ItemIsDropEnabled | Qt::ItemIsDragEnabled;
}
else {
return QAbstractTableModel::flags(index) | Qt::ItemIsEditable | Qt::ItemIsDropEnabled | Qt::ItemIsDragEnabled;
}
}
bool PlaylistModel::setData(const QModelIndex &index, const QVariant &value, int role) {
if (index.isValid() && role == Qt::EditRole) {
int row = index.row();
switch(index.column()) {
case 0:
// title
m_data[row]["Title"] = value.toString();
emit(QAbstractItemModel::dataChanged(index, index));
break;
case 1:
// artist
m_data[row]["Artist"] = value.toString();
emit(QAbstractItemModel::dataChanged(index, index));
break;
case 2:
// album
m_data[row]["Album"] = value.toString();
emit(QAbstractItemModel::dataChanged(index, index));
break;
default:
break;
}
changeMetaData(index);
qDebug() << "playlistModel::setData()";
emit(playlistMetaDataChange(m_data[row]));
return true;
}
return false;
}
Qt::DropActions PlaylistModel::supportedDropActions() const {
return Qt::CopyAction | Qt::MoveAction;
}
QStringList PlaylistModel::mimetypes() const {
QStringList types;
types << "myMediaItem";
return types;
}
QMimeData *PlaylistModel::mimeData(const QModelIndexList &indexes) const {
//qDebug() << "PlaylistModel::mimeData() called with indexes=" << indexes;
QMimeData *mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
QModelIndex index = indexes[0];
int row = -1;
QString header = "playlistItem";
stream << header; // mimeData header;
foreach(index, indexes) {
if (index.isValid()) {
#if DEBUG_PLAYLIST
qDebug()<< "row for index is: " << row;
#endif
if (index.row() != row) {
row = index.row();
stream << row;
}
}
}
mimeData->setData("myMediaItem", encodedData);
#if DEBUG_PLAYLIST
qDebug()<< "Called mimeData with indexes=" << indexes;
#endif
return mimeData;
}
void PlaylistModel::swapSong(int to, QList<int> fromList, int offset) {
//moving songs down
if (to == -1) {
#if DEBUG_PLAYLIST
qDebug() << "Moving to end";
#endif
for (int i=0; i < fromList.size(); i++) {
m_data.append(m_data[fromList[0]]);
m_data.removeAt(fromList[0]);
if (curMediaIdx == fromList[i]) {
curMediaIdx = (m_data.size()-1)-(fromList.size()-1)+i;
}
}
}
if (offset > 0) {
#if DEBUG_PLAYLIST
qDebug() << "Moving down";
#endif
for (int i=0; i < fromList.size(); i++) {
m_data.move(fromList[0], to);
if (curMediaIdx == fromList[i]) {
curMediaIdx = to-(fromList.size()-1)+i;
}
}
}
if (offset < 0 && to>=0) {
// moving songs up
if (to == 0) {
#if DEBUG_PLAYLIST
qDebug() << "Moving to beginning";
#endif
m_data.prepend(m_data[fromList[0]]);
m_data.removeAt(fromList[0]+1);
if (curMediaIdx == fromList[0]) {
curMediaIdx = 0;
}
for (int i=1; i < fromList.size(); i++) {
m_data.move(fromList[i], 1);
if (curMediaIdx == fromList[i]) {
curMediaIdx = i;
}
}
}
else {
#if DEBUG_PLAYLIST
qDebug() << "Moving up";
#endif
for (int i=0; i < fromList.size(); i++) {
m_data.move(fromList[i], to+i);
if (curMediaIdx == fromList[i]) {
curMediaIdx = to+i;
}
}
}
}
emit(dataChanged(index(0,0), index(m_data.size()-1, columns)));
}
// open() button uses this
void PlaylistModel::addMedia(const QStringList& fileNames) {
// append media to end of m_data
int start = m_data.size();
foreach(QString const &path, fileNames) {
QHash<QString, QString> hash;
u->get_metaData(path, hash);
if (!hash.empty()) {
beginInsertRows(QModelIndex(), start, start);
m_data.append(hash);
start = start+1;
emit(mediaAddedToPlaylist(hash["absFilePath"]));
endInsertRows();
}
}
if (curMediaIdx < 0 && start > 0) {
curMediaIdx = 0;
emit(mediaAvailable());
}
}
// library doubleclick uses this
void PlaylistModel::addMedia(const QHash<QString, QString> libraryItem) {
beginInsertRows(QModelIndex(), m_data.size(), m_data.size());
m_data.append(libraryItem);
endInsertRows();
if (curMediaIdx < 0) {
curMediaIdx = 0;
emit(mediaAvailable());
}
}
void PlaylistModel::addMediaList(const QList<QHash<QString, QString> > libraryItemList) {
QHash<QString, QString> item;
foreach(item, libraryItemList) {
addMedia(item);
}
}
void PlaylistModel::removeMedia(int start, int end) {
beginRemoveRows(QModelIndex(), start, end);
for (int i=0; i < end-start+1; i++) {
m_data.removeAt(start);
if (curMediaIdx == start+i) {
curMediaIdx = (m_data.size()>0) ? 0 : -1;
emit(curMediaRemoved(curMediaIdx));
}
}
endRemoveRows();
if (m_data.size() == 0) {
curMediaIdx = -1;
emit(curMediaRemoved(curMediaIdx));
}
}
const QMediaContent PlaylistModel::setCurMedia(int row){
// set current media to row
if (row >= 0 && row < m_data.size()) {
curMediaIdx = row;
QUrl url = QUrl::fromLocalFile(m_data[curMediaIdx]["absFilePath"]);
emit(currentIndexChanged(curMediaIdx));
return url;
}
else {
return QMediaContent();
}
}
const QMediaContent PlaylistModel::nextMedia(){
// set current media to the next entry, when called after the previous one finished playing
// and returns the media content.
finishedPlaylist = false;
if (m_data.size() > 0) {
if (curMediaIdx == m_data.size()-1) {
finishedPlaylist = true;
}
if ( mode & REPEAT1 ) {
// mode is repeat 1
curMediaIdx = curMediaIdx;
}
else if (mode & SHUFFLE) {
curMediaIdx = qrand() % m_data.size();
}
else {
if (finishedPlaylist) {
curMediaIdx = 0;
}
else {
curMediaIdx++;
}
}
QUrl url = QUrl::fromLocalFile(m_data[curMediaIdx]["absFilePath"]);
emit(currentIndexChanged(curMediaIdx));
return url;
}
return QMediaContent();
}
const QMediaContent PlaylistModel::pressNextMedia() {
finishedPlaylist = false;
if (m_data.size() > 0) {
if (mode & SHUFFLE) {
curMediaIdx = qrand() % m_data.size();
}
else {
curMediaIdx = (curMediaIdx+1) % m_data.size();
}
QUrl url = QUrl::fromLocalFile(m_data[curMediaIdx]["absFilePath"]);
emit(currentIndexChanged(curMediaIdx));
return url;
}
return QMediaContent();
}
const QMediaContent PlaylistModel::currentMedia() {
if (curMediaIdx >= 0) {
qDebug() << "Getting current media";
QUrl url = QUrl::fromLocalFile(m_data[curMediaIdx]["absFilePath"]);
return url;
}
else {
return QMediaContent();
}
}
const QMediaContent PlaylistModel::previousMedia() {
// set and return the previous entry
if (m_data.size() > 0) {
if (curMediaIdx == 0) {
curMediaIdx = m_data.size()-1;
}
else {
curMediaIdx = curMediaIdx-1;
}
QUrl url = QUrl::fromLocalFile(m_data[curMediaIdx]["absFilePath"]);
emit(currentIndexChanged(curMediaIdx));
return url;
}
return QMediaContent();
}
int PlaylistModel::getCurMediaIdx() const{
return curMediaIdx;
}
QModelIndex PlaylistModel::getCurMediaModelIndex() const {
return index(curMediaIdx, 0);
}
int PlaylistModel::getColumns() const {
return columns;
}
bool PlaylistModel::keepPlaying() const {
// keep playing if not mode repeatall or shuffle or repeat1
return !(finishedPlaylist && (mode == NORMAL));
}
void PlaylistModel::setMode(int newMode, bool checked) {
if (checked) {
// set mode
mode |= newMode;
}
else {
mode &= ~newMode;
}
}
void PlaylistModel::clear() {
// delete all the playlist entries and rest curMediaIdx;
beginRemoveRows(QModelIndex(), 0, m_data.size()-1);
m_data.clear();
endRemoveRows();
curMediaIdx = -1;
}
const QString PlaylistModel::getCurAlbumArtist() const {
//qDebug() << "getCurAlbumArtist(): idx=" << curMediaIdx;
if (curMediaIdx >= 0) {
return QString("%1 - %2")
.arg(m_data[curMediaIdx]["Album"])
.arg(m_data[curMediaIdx]["Artist"]);
}
return QString();
}
const QString PlaylistModel::getCurTitle() const {
//qDebug() << "getCurTitle(): idx=" << curMediaIdx;
if (curMediaIdx >= 0) {
return m_data[curMediaIdx]["Title"];
}
return QString();
}
void PlaylistModel::beginRemoveItems(int start, int end) {
beginRemoveRows(QModelIndex(), start, end);
for (int row=0; row < end+1; row++) {
m_data.removeAt(row);
}
}
void PlaylistModel::endRemoveItems() {
endInsertRows();
}
void PlaylistModel::changeItems(int start, int end) {
emit dataChanged(index(start,0), index(end,columns));
}
void PlaylistModel::changeMetaData(QModelIndex index) {
int row = index.row();
int col = index.column();
// get path of the associated file
//QUrl location = m_playlist->media(row).canonicalUrl();
//QString path = location.path();
QByteArray byteArray = m_data[row]["absFilePath"].toUtf8();
const char* cString = byteArray.constData();
TagLib::FileRef f(cString);
if (!f.isNull() && f.tag()) {
switch (col) {
case 0: {
// change title
TagLib::String title = TagLib::String(m_data[row]["Title"].toUtf8().constData());
f.tag()->setTitle(title);
f.file()->save();
break;
}
case 1: {
// change artist
TagLib::String artist = TagLib::String(m_data[row]["Artist"].toUtf8().constData());
f.tag()->setArtist(artist);
f.file()->save();
break;
}
case 2: {
// change album
TagLib::String album = TagLib::String(m_data[row]["Album"].toUtf8().constData());
f.tag()->setAlbum(album);
f.file()->save();
break;
}
default:
break;
}
}
return;
}
void PlaylistModel::libraryMetaDataChanged(int dataType, QString arg1, QString arg2) {
// either title or artist in library have been changed,
// alter the affected playlist items accordingly.
if (dataType == 0) {
// title change
QString absFilePath = arg1;
QString newTitle = arg2;
for(int row = 0; row < m_data.size(); row++) {
if (m_data[row]["absFilePath"] == absFilePath) {
m_data[row]["Title"] = newTitle;
emit(dataChanged(index(row,0), index(row,0)));
}
}
}
if (dataType == 1) {
// artist change
QString oldArtist = arg1;
QString newArtist = arg2;
for(int row = 0; row < m_data.size(); row++) {
if (m_data[row]["Artist"] == oldArtist) {
m_data[row]["Artist"] = newArtist;
emit(dataChanged(index(row,0), index(row,0)));
}
}
}
}
| [
"april.dai0415@gmail.com"
] | april.dai0415@gmail.com |
97da6f0630150ae5cb5b3baa21c9a4913e1bb023 | e3c98a275785b7308d1f261aa09716e2523c539d | /Sic Assembler/Src/Parser/InterFileParser.h | 1de453c4b3ae14cca32bd174492137f5a402fe56 | [] | no_license | BassentZaghloul/SICMachine_Assembler | aaf186835568678f0748bd253cdfe532763f486f | 5df860fadd4ccd6408e73c7a132464d817b28206 | refs/heads/master | 2020-12-02T08:16:59.389758 | 2017-07-10T17:10:30 | 2017-07-10T17:10:30 | 96,800,243 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 456 | h | //
// Created by me on 5/22/2017.
//
#ifndef SICASSEMBLERV2_INTERFILEPARSER_H
#define SICASSEMBLERV2_INTERFILEPARSER_H
#include "GeneratedFileParser.h"
class InterFileParser : public GeneratedFileParser{
public:
InterFileParser(OpTable *optable, DirectiveTable *directiveTable, SymbolTable *symbolTable,LiteralTable* literalTable);
void parseIntermediateFile(std::string s);
};
#endif //SICASSEMBLERV2_INTERFILEPARSER_H
| [
"me@BassentZaghloul"
] | me@BassentZaghloul |
8059c26235ea7ef06eb97d05429bed8ccb07d9d1 | df1279323e3216076f514ea9e93c330c7f77675f | /Tai-tai/exlabel.h | a194ee557f591026020580cde70992c80948331d | [] | no_license | AntonGulkevich/Tai-tai | 4a35ac13249d881a88022237b33cefa3a4d6c452 | ba66ed8af934dbcb6191bf69cadc41e2ffdf94e4 | refs/heads/master | 2021-01-23T13:59:08.490243 | 2015-08-18T12:43:16 | 2015-08-18T12:43:16 | 31,409,723 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,465 | h | #ifndef EXLABEL_H
#define EXLABEL_H
#include <QLabel>
#include <QFont>
#include <QMouseEvent>
class ExLabel : public QLabel
{
Q_OBJECT
public:
explicit ExLabel(const QString &text, QWidget *parent = 0);
~ExLabel();
void SetSelectedFont(const QFont &font);
void SetUnSelectedFont(const QFont &font);
void SetActiveFont(const QFont &font);
bool isActive();
void setActive(bool status);
void setActiveStyleSheet(const QString& ss);
void setInActiveStyleSheet(const QString& ss);
void incActiveFont();
void incUnselectedFont();
void incSelectedFont();
void decrActiveFont();
void decrUnselectedFont();
void decrSelectedFont();
void setActiveFontSize(int size);
void setSelectedFontSize(int size);
void setUnselectedFontSize(int size);
void setFonts(int act , int sel, int uns);
void setDinamicSS(bool mode);
bool isDinamicSS();
signals:
void clicked();
void mouseEntered();
void mouseLeaved();
public slots:
void OnClick();
protected:
virtual void mousePressEvent(QMouseEvent* pe);
virtual void mouseReleaseEvent(QMouseEvent* pe);
virtual void leaveEvent(QEvent * event);
virtual void enterEvent(QEvent *event);
private:
QFont *selectedFont;
QFont *unselectedFont;
QFont *activeFont;
bool active;
bool dinamicSS;
QPoint pos;
QString activeStyleSheet;
QString inActiveStyleSheet;
};
#endif // EXLABEL_H
| [
"ycykensmit@gmail.com"
] | ycykensmit@gmail.com |
b3ce02ddb172866fd9c6b7c98f8cbc34c2c1fdee | c4aa092e45dc943ed3932a796a0870ce84714500 | /IDETools/WkspLoadDialog.cpp | cf92f64b0064e944ce554b9fd26221706a0b3f97 | [] | no_license | 15831944/DevTools | d07897dd7a36afa6d287cac72a54589da15f968d | 50723004dc9c705e8f095d6f503beeb4096e4987 | refs/heads/master | 2022-11-21T05:41:56.927474 | 2020-07-24T12:30:59 | 2020-07-24T12:30:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,789 | cpp |
#include "stdafx.h"
#include "WkspLoadDialog.h"
#include "WorkspaceProfile.h"
#include "Application_fwd.h"
#include "resource.h"
#include "utl/Registry.h"
#include "utl/UI/MenuUtilities.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
namespace layout
{
static CLayoutStyle styles[] =
{
{ IDC_PROJECT_NAME_COMBO, SizeX },
{ IDC_FILES_LIST, Size },
{ IDC_SHOW_FULL_PATH_CHECK, MoveX },
{ IDC_FULLPATH_STATIC, MoveY },
{ IDC_FULLPATH_EDIT, MoveY | SizeX },
{ IDOK, MoveX },
{ IDCANCEL, MoveX },
{ IDC_BEFORE_OPEN_STATIC, Move },
{ IDC_CLOSE_ALL_BEFORE_OPEN_CHECK, Move }
};
}
CWkspLoadDialog::CWkspLoadDialog( WorkspaceProfile& rWkspProfile, const CString& section, const CString& currProjectName, CWnd* pParent )
: CLayoutDialog( IDD_WORKSPACE_LOAD_DIALOG, pParent )
, m_section( section )
, m_currProjectName( currProjectName )
, m_rWkspProfile( rWkspProfile )
, m_options( NULL )
, m_folderItem( _T("") )
, m_fullPathEdit( ui::FilePath )
{
m_regSection = ::sectionWorkspaceDialogs;
RegisterCtrlLayout( layout::styles, COUNT_OF( layout::styles ) );
LoadDlgIcon( IDD_WORKSPACE_LOAD_DIALOG );
m_accelPool.AddAccelTable( new CAccelTable( IDR_WKSPLOAD_ACCEL ) );
CWinApp* pApp = AfxGetApp();
m_options.m_displayFullPath = pApp->GetProfileInt( m_regSection.c_str(), ENTRY_MEMBER( m_displayFullPath ), m_options.m_displayFullPath ) != FALSE;
m_options.m_sortFolders = false;
m_options.m_fileSortOrder.Clear();
if ( m_section.IsEmpty() )
m_section = ::defaulWkspSection;
m_rWkspProfile.m_mustCloseAll = pApp->GetProfileInt( m_regSection.c_str(), ENTRY_OF( mustCloseAll ), m_rWkspProfile.m_mustCloseAll );
}
CWkspLoadDialog::~CWkspLoadDialog()
{
}
void CWkspLoadDialog::setupWindow( void )
{
ASSERT( IsWindow( m_hWnd ) );
loadExistingProjects();
for ( unsigned int i = 0; i != m_rWkspProfile.projectNameArray.size(); ++i )
m_projectNameCombo.AddString( m_rWkspProfile.projectNameArray[ i ] );
if ( m_projectNameCombo.SelectString( -1, m_currProjectName ) == -1 )
m_projectNameCombo.SetCurSel( 0 );
updateFileContents();
}
void CWkspLoadDialog::cleanupWindow( void )
{
CWinApp* pApp = AfxGetApp();
pApp->WriteProfileInt( m_regSection.c_str(), ENTRY_MEMBER( m_displayFullPath ), m_options.m_displayFullPath );
pApp->WriteProfileInt( m_regSection.c_str(), ENTRY_OF( mustCloseAll ), m_rWkspProfile.m_mustCloseAll );
}
bool CWkspLoadDialog::loadExistingProjects( void )
{
// Enums the already stored projects keys, by ex:
// HKEY_CURRENT_USER\Software\RegistryKey\AppName\section\Project1
reg::CKey projectsKey( AfxGetApp()->GetSectionKey( m_section ) );
if ( !projectsKey.IsOpen() )
return false;
std::vector< std::tstring > projects;
projectsKey.QuerySubKeyNames( projects );
for ( std::vector< std::tstring >::const_iterator itProject = projects.begin(); itProject != projects.end(); ++itProject )
m_rWkspProfile.AddProjectName( itProject->c_str() );
return !projects.empty();
}
void CWkspLoadDialog::updateFileContents( void )
{
m_folderItem.Clear();
if ( readProjectName() )
{
reg::CKey workspacesKey( AfxGetApp()->GetSectionKey( m_section ) );
if ( workspacesKey.IsOpen() )
{
reg::CKey projectKey;
if ( projectKey.Open( workspacesKey.Get(), m_currProjectName.GetString(), KEY_READ ) )
{
std::vector< std::tstring > valueNames;
projectKey.QueryValueNames( valueNames );
for ( std::vector< std::tstring >::const_iterator itValueName = valueNames.begin(); itValueName != valueNames.end(); ++itValueName )
m_folderItem.AddFileItem( NULL, projectKey.ReadStringValue( itValueName->c_str() ) ); // was m_rWkspProfile.getFileEntryName( i )
}
}
}
m_fileList.SetRedraw( FALSE );
m_fileList.ResetContent();
const std::vector< CFileItem* >& fileItems = m_folderItem.GetFileItems();
for ( unsigned int index = 0; index != fileItems.size(); ++index )
{
CFileItem* pFileItem = fileItems[ index ];
m_fileList.AddString( pFileItem->FormatLabel( &m_options ).c_str() );
m_fileList.SetItemDataPtr( index, pFileItem );
}
m_fileList.SetSel( -1, TRUE );
m_fileList.SetRedraw( TRUE );
m_fileList.Invalidate();
m_fileList.SetCaretIndex( 0 );
LBnSelChangeFiles();
}
bool CWkspLoadDialog::transferFiles( void )
{
if ( !readProjectName() )
return false;
size_t selCount = m_fileList.GetSelCount();
m_rWkspProfile.fileArray.clear();
if ( selCount != 0 )
{
std::vector< int > selection( selCount );
VERIFY( m_fileList.GetSelItems( selCount, &selection.front() ) != LB_ERR );
for ( size_t i = 0; i < selCount; ++i )
m_rWkspProfile.fileArray.push_back( GetListFileItem( selection[ i ] )->GetFilePath().GetPtr() );
}
return true;
}
bool CWkspLoadDialog::readProjectName( void )
{
int selIndex = m_projectNameCombo.GetCurSel();
m_currProjectName.Empty();
if ( selIndex != CB_ERR )
m_projectNameCombo.GetLBText( selIndex, m_currProjectName );
if ( !m_currProjectName.IsEmpty() )
return true;
return false;
}
void CWkspLoadDialog::handleSelection( Ternary operation )
{
if ( operation != Toggle )
m_fileList.SetSel( -1, operation );
else
{ // Toggle
for ( int i = 0, count = m_fileList.GetCount(); i < count; ++i )
m_fileList.SetSel( i, !m_fileList.GetSel( i ) );
}
}
void CWkspLoadDialog::DoDataExchange( CDataExchange* pDX )
{
DDX_Control( pDX, IDC_PROJECT_NAME_COMBO, m_projectNameCombo );
DDX_Control( pDX, IDC_FILES_LIST, m_fileList );
DDX_Control( pDX, IDC_FULLPATH_EDIT, m_fullPathEdit );
CLayoutDialog::DoDataExchange( pDX );
}
// message handlers
BEGIN_MESSAGE_MAP( CWkspLoadDialog, CLayoutDialog )
ON_WM_DESTROY()
ON_WM_CONTEXTMENU()
ON_BN_CLICKED( IDC_SHOW_FULL_PATH_CHECK, CkShowFullPath )
ON_BN_CLICKED( IDC_CLOSE_ALL_BEFORE_OPEN_CHECK, CkCloseAllBeforeOpen )
ON_CBN_SELCHANGE( IDC_PROJECT_NAME_COMBO, CBnSelChangeProjectName )
ON_LBN_SELCHANGE( IDC_FILES_LIST, LBnSelChangeFiles )
ON_COMMAND_RANGE( CM_MULTISEL_SELECT_ALL, CM_MULTISEL_TOGGLE_SEL, CmMultiSelection )
END_MESSAGE_MAP()
BOOL CWkspLoadDialog::OnInitDialog( void )
{
CLayoutDialog::OnInitDialog();
CheckDlgButton( IDC_SHOW_FULL_PATH_CHECK, m_options.m_displayFullPath );
CheckDlgButton( IDC_CLOSE_ALL_BEFORE_OPEN_CHECK, m_rWkspProfile.m_mustCloseAll );
setupWindow();
return TRUE;
}
void CWkspLoadDialog::OnDestroy( void )
{
cleanupWindow();
CLayoutDialog::OnDestroy();
}
void CWkspLoadDialog::OnOK( void )
{
transferFiles();
CLayoutDialog::OnOK();
}
void CWkspLoadDialog::OnContextMenu( CWnd* pWnd, CPoint point )
{
if ( pWnd == &m_fileList )
{
CMenu contextMenu;
ui::LoadPopupMenu( contextMenu, IDR_CONTEXT_MENU, app::ProfileListContextPopup );
if ( point.x == -1 || point.y == -1 )
::GetCursorPos( &point );
contextMenu.TrackPopupMenu( TPM_RIGHTBUTTON, point.x, point.y, this );
}
}
void CWkspLoadDialog::CkShowFullPath( void )
{
m_options.m_displayFullPath = IsDlgButtonChecked( IDC_SHOW_FULL_PATH_CHECK ) != FALSE;
m_fileList.SetCurSel( -1 );
updateFileContents();
}
void CWkspLoadDialog::CkCloseAllBeforeOpen( void )
{
m_rWkspProfile.m_mustCloseAll = IsDlgButtonChecked( IDC_CLOSE_ALL_BEFORE_OPEN_CHECK );
}
void CWkspLoadDialog::CBnSelChangeProjectName( void )
{
updateFileContents();
}
void CWkspLoadDialog::LBnSelChangeFiles( void )
{
int caretIndex = m_fileList.GetCaretIndex();
fs::CPath fullPath;
if ( caretIndex != LB_ERR && caretIndex < m_fileList.GetCount() )
fullPath = m_folderItem.GetFileItems()[ caretIndex ]->GetFilePath();
SetDlgItemText( IDC_FULLPATH_EDIT, fullPath.GetPtr() );
}
void CWkspLoadDialog::CmMultiSelection( UINT cmdId )
{
switch ( cmdId )
{
case CM_MULTISEL_SELECT_ALL:
handleSelection( True );
break;
case CM_MULTISEL_CLEAR_ALL:
handleSelection( False );
break;
case CM_MULTISEL_TOGGLE_SEL:
handleSelection( Toggle );
break;
}
}
| [
"phc.2nd@gmail.com"
] | phc.2nd@gmail.com |
11ffb70c3b39034ff38ac56d0c1344c210bbfe8a | fc5cf6e087df5b7934ceed7d2a1d22b094197ff1 | /processed_old/130-6741-1.cc | ae726733548b99f400240dba09768aedc3070d99 | [
"MIT",
"GPL-2.0-only",
"GPL-1.0-or-later"
] | permissive | giulianobelinassi/LTO-Timing-Analysis | 80767a682960d2f2b1944edaf116466a784ac984 | 12eb7f3444f6c938c0a225f61aec47e419526490 | refs/heads/master | 2023-01-30T09:20:12.705767 | 2020-12-10T00:30:16 | 2020-12-10T00:30:16 | 263,368,860 | 1 | 0 | MIT | 2020-10-27T23:16:33 | 2020-05-12T14:59:34 | C++ | UTF-8 | C++ | false | false | 2,355,889 | cc | # 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
# 1 "/home/giulianob/gcc_git_gnu/build_temp/gcc//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
# 1 "./config.h" 1
# 1 "./auto-host.h" 1
# 7 "./config.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h" 1
# 40 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h"
extern "C" {
# 433 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h"
}
# 9 "./config.h" 2
# 94 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 1
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 99 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 33 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 43 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 143 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 209 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 415 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
# 426 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4
} max_align_t;
typedef decltype(nullptr) nullptr_t;
# 44 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 461 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 453 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 462 "/usr/include/features.h" 2 3 4
# 485 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 486 "/usr/include/features.h" 2 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 2 3 4
# 28 "/usr/include/stdio.h" 2 3 4
extern "C" {
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
typedef int __sig_atomic_t;
# 39 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4
typedef struct _G_fpos_t
{
__off_t __pos;
__mbstate_t __state;
} __fpos_t;
# 40 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
typedef struct _G_fpos64_t
{
__off64_t __pos;
__mbstate_t __state;
} __fpos64_t;
# 41 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE __FILE;
# 42 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
struct _IO_FILE;
typedef struct _IO_FILE FILE;
# 43 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
struct _IO_FILE;
struct _IO_marker;
struct _IO_codecvt;
struct _IO_wide_data;
typedef void _IO_lock_t;
struct _IO_FILE
{
int _flags;
char *_IO_read_ptr;
char *_IO_read_end;
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
# 44 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 3 4
typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf,
size_t __nbytes);
typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf,
size_t __nbytes);
typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w);
typedef int cookie_close_function_t (void *__cookie);
typedef struct _IO_cookie_io_functions_t
{
cookie_read_function_t *read;
cookie_write_function_t *write;
cookie_seek_function_t *seek;
cookie_close_function_t *close;
} cookie_io_functions_t;
# 47 "/usr/include/stdio.h" 2 3 4
# 63 "/usr/include/stdio.h" 3 4
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __ssize_t ssize_t;
typedef __fpos_t fpos_t;
typedef __fpos64_t fpos64_t;
# 133 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 134 "/usr/include/stdio.h" 2 3 4
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
# 164 "/usr/include/stdio.h" 3 4
extern int renameat2 (int __oldfd, const char *__old, int __newfd,
const char *__new, unsigned int __flags) throw ();
extern FILE *tmpfile (void) ;
# 183 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
# 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
# 227 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 237 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
# 246 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
# 270 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
;
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
;
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw () __asm__ ("" "__isoc99_sscanf")
;
# 432 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vsscanf")
__attribute__ ((__format__ (__scanf__, 2, 0)));
# 485 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 510 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 521 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
# 537 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
# 587 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
# 603 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
# 662 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
# 673 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
# 707 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
# 731 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 750 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
extern void perror (const char *__s);
# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
# 782 "/usr/include/stdio.h" 2 3 4
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
# 800 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
# 858 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
{
return vfprintf (stdout, __fmt, __arg);
}
extern __inline __attribute__ ((__gnu_inline__)) int
getchar (void)
{
return getc (stdin);
}
extern __inline __attribute__ ((__gnu_inline__)) int
fgetc_unlocked (FILE *__fp)
{
return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}
extern __inline __attribute__ ((__gnu_inline__)) int
getc_unlocked (FILE *__fp)
{
return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}
extern __inline __attribute__ ((__gnu_inline__)) int
getchar_unlocked (void)
{
return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}
extern __inline __attribute__ ((__gnu_inline__)) int
putchar (int __c)
{
return putc (__c, stdout);
}
extern __inline __attribute__ ((__gnu_inline__)) int
fputc_unlocked (int __c, FILE *__stream)
{
return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}
extern __inline __attribute__ ((__gnu_inline__)) int
putc_unlocked (int __c, FILE *__stream)
{
return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}
extern __inline __attribute__ ((__gnu_inline__)) int
putchar_unlocked (int __c)
{
return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
return __getdelim (__lineptr, __n, '\n', __stream);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
{
return (((__stream)->_flags & 0x0010) != 0);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
{
return (((__stream)->_flags & 0x0020) != 0);
}
# 865 "/usr/include/stdio.h" 2 3 4
# 873 "/usr/include/stdio.h" 3 4
}
# 47 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 103 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 103 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern "C" {
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
}
# 209 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h" 1
# 57 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h"
enum {
_sch_isblank = 0x0001,
_sch_iscntrl = 0x0002,
_sch_isdigit = 0x0004,
_sch_islower = 0x0008,
_sch_isprint = 0x0010,
_sch_ispunct = 0x0020,
_sch_isspace = 0x0040,
_sch_isupper = 0x0080,
_sch_isxdigit = 0x0100,
_sch_isidst = 0x0200,
_sch_isvsp = 0x0400,
_sch_isnvsp = 0x0800,
_sch_isalpha = _sch_isupper|_sch_islower,
_sch_isalnum = _sch_isalpha|_sch_isdigit,
_sch_isidnum = _sch_isidst|_sch_isdigit,
_sch_isgraph = _sch_isalnum|_sch_ispunct,
_sch_iscppsp = _sch_isvsp|_sch_isnvsp,
_sch_isbasic = _sch_isprint|_sch_iscppsp
};
extern const unsigned short _sch_istable[256];
# 110 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h"
extern const unsigned char _sch_toupper[256];
extern const unsigned char _sch_tolower[256];
# 122 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h"
# 1 "/usr/include/ctype.h" 1 3 4
# 28 "/usr/include/ctype.h" 3 4
# 28 "/usr/include/ctype.h" 3 4
extern "C" {
# 39 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
# 40 "/usr/include/ctype.h" 2 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 79 "/usr/include/ctype.h" 3 4
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
# 108 "/usr/include/ctype.h" 3 4
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 174 "/usr/include/ctype.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int isalnum (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISalnum; }
extern __inline __attribute__ ((__gnu_inline__)) int isalpha (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISalpha; }
extern __inline __attribute__ ((__gnu_inline__)) int iscntrl (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IScntrl; }
extern __inline __attribute__ ((__gnu_inline__)) int isdigit (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISdigit; }
extern __inline __attribute__ ((__gnu_inline__)) int islower (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISlower; }
extern __inline __attribute__ ((__gnu_inline__)) int isgraph (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISgraph; }
extern __inline __attribute__ ((__gnu_inline__)) int isprint (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISprint; }
extern __inline __attribute__ ((__gnu_inline__)) int ispunct (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISpunct; }
extern __inline __attribute__ ((__gnu_inline__)) int isspace (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISspace; }
extern __inline __attribute__ ((__gnu_inline__)) int isupper (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISupper; }
extern __inline __attribute__ ((__gnu_inline__)) int isxdigit (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISxdigit; }
extern __inline __attribute__ ((__gnu_inline__)) int isblank (int __c) throw () { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _ISblank; }
# 206 "/usr/include/ctype.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) tolower (int __c) throw ()
{
return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) toupper (int __c) throw ()
{
return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
}
# 237 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4
struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
};
typedef struct __locale_struct *__locale_t;
# 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4
typedef __locale_t locale_t;
# 238 "/usr/include/ctype.h" 2 3 4
# 251 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, locale_t) throw ();
extern int isalpha_l (int, locale_t) throw ();
extern int iscntrl_l (int, locale_t) throw ();
extern int isdigit_l (int, locale_t) throw ();
extern int islower_l (int, locale_t) throw ();
extern int isgraph_l (int, locale_t) throw ();
extern int isprint_l (int, locale_t) throw ();
extern int ispunct_l (int, locale_t) throw ();
extern int isspace_l (int, locale_t) throw ();
extern int isupper_l (int, locale_t) throw ();
extern int isxdigit_l (int, locale_t) throw ();
extern int isblank_l (int, locale_t) throw ();
extern int __tolower_l (int __c, locale_t __l) throw ();
extern int tolower_l (int __c, locale_t __l) throw ();
extern int __toupper_l (int __c, locale_t __l) throw ();
extern int toupper_l (int __c, locale_t __l) throw ();
# 327 "/usr/include/ctype.h" 3 4
}
# 123 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/safe-ctype.h" 2
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
extern "C" {
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
typedef __ino64_t ino64_t;
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
# 97 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __pid_t pid_t;
typedef __id_t id_t;
# 114 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4
typedef __clock_t clock_t;
# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4
typedef __clockid_t clockid_t;
# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
typedef __time_t time_t;
# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4
typedef __timer_t timer_t;
# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __useconds_t useconds_t;
typedef __suseconds_t suseconds_t;
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;
typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{
return __builtin_bswap16 (__bsx);
}
static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{
return __builtin_bswap32 (__bsx);
}
# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
return __builtin_bswap64 (__bsx);
}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
return __x;
}
static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
return __x;
}
static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
return __x;
}
# 37 "/usr/include/endian.h" 2 3 4
# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4
typedef __sigset_t sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
# 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef long int __fd_mask;
# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern "C" {
# 101 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 113 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
# 126 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
}
# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 74 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
};
# 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
# 87 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
unsigned int __readers;
unsigned int __writers;
unsigned int __wrphase_futex;
unsigned int __writers_futex;
unsigned int __pad3;
unsigned int __pad4;
int __cur_writer;
int __shared;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
};
# 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
struct __pthread_cond_s
{
__extension__ union
{
__extension__ unsigned long long int __wseq;
struct
{
unsigned int __low;
unsigned int __high;
} __wseq32;
};
__extension__ union
{
__extension__ unsigned long long int __g1_start;
struct
{
unsigned int __low;
unsigned int __high;
} __g1_start32;
};
unsigned int __g_refs[2] ;
unsigned int __g_size[2];
unsigned int __g1_orig_size;
unsigned int __wrefs;
unsigned int __g_signals[2];
};
# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
typedef unsigned long int pthread_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef union
{
struct __pthread_mutex_s __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
struct __pthread_cond_s __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
struct __pthread_rwlock_arch_t __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
}
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/errno.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 6 "/usr/include/asm-generic/errno.h" 2 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/errno.h" 2 3 4
# 2 "/usr/include/linux/errno.h" 2 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/errno.h" 2 3 4
# 29 "/usr/include/errno.h" 2 3 4
extern "C" {
extern int *__errno_location (void) throw () __attribute__ ((__const__));
extern char *program_invocation_name;
extern char *program_invocation_short_name;
# 1 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 3 4
typedef int error_t;
# 49 "/usr/include/errno.h" 2 3 4
}
# 214 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 235 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/c++/10/cstring" 1 3
# 39 "/usr/include/c++/10/cstring" 3
# 40 "/usr/include/c++/10/cstring" 3
# 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 1 3
# 262 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
# 284 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3
namespace std
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
# 522 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3
# 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/os_defines.h" 1 3
# 523 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3
# 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/cpu_defines.h" 1 3
# 526 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3
# 42 "/usr/include/c++/10/cstring" 2 3
# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4
extern "C" {
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4
# 43 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
memchr (void *__s, int __c, size_t __n) throw ()
{
return __builtin_memchr (__s, __c, __n);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
memchr (const void *__s, int __c, size_t __n) throw ()
{
return __builtin_memchr (__s, __c, __n);
}
}
# 99 "/usr/include/string.h" 3 4
extern "C++" void *rawmemchr (void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 122 "/usr/include/string.h" 3 4
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 204 "/usr/include/string.h" 3 4
extern "C++"
{
extern char *strchr (char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strchr (char *__s, int __c) throw ()
{
return __builtin_strchr (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strchr (const char *__s, int __c) throw ()
{
return __builtin_strchr (__s, __c);
}
}
extern "C++"
{
extern char *strrchr (char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strrchr (char *__s, int __c) throw ()
{
return __builtin_strrchr (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strrchr (const char *__s, int __c) throw ()
{
return __builtin_strrchr (__s, __c);
}
}
# 261 "/usr/include/string.h" 3 4
extern "C++" char *strchrnul (char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 273 "/usr/include/string.h" 3 4
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strpbrk (char *__s, const char *__accept) throw ()
{
return __builtin_strpbrk (__s, __accept);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strpbrk (const char *__s, const char *__accept) throw ()
{
return __builtin_strpbrk (__s, __accept);
}
}
extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strstr (char *__haystack, const char *__needle) throw ()
{
return __builtin_strstr (__haystack, __needle);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strstr (const char *__haystack, const char *__needle) throw ()
{
return __builtin_strstr (__haystack, __needle);
}
}
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 369 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
# 421 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, locale_t __l) throw ();
# 1 "/usr/include/strings.h" 1 3 4
# 23 "/usr/include/strings.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/strings.h" 2 3 4
extern "C" {
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++"
{
extern char *index (char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
index (char *__s, int __c) throw ()
{
return __builtin_index (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
index (const char *__s, int __c) throw ()
{
return __builtin_index (__s, __c);
}
}
extern "C++"
{
extern char *rindex (char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
rindex (char *__s, int __c) throw ()
{
return __builtin_rindex (__s, __c);
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
rindex (const char *__s, int __c) throw ()
{
return __builtin_rindex (__s, __c);
}
}
# 104 "/usr/include/strings.h" 3 4
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
}
# 433 "/usr/include/string.h" 2 3 4
extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" char *basename (char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 499 "/usr/include/string.h" 3 4
}
# 43 "/usr/include/c++/10/cstring" 2 3
# 71 "/usr/include/c++/10/cstring" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
# 122 "/usr/include/c++/10/cstring" 3
}
}
# 236 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/c++/10/new" 1 3
# 38 "/usr/include/c++/10/new" 3
# 39 "/usr/include/c++/10/new" 3
# 1 "/usr/include/c++/10/exception" 1 3
# 33 "/usr/include/c++/10/exception" 3
# 34 "/usr/include/c++/10/exception" 3
#pragma GCC visibility push(default)
# 1 "/usr/include/c++/10/bits/exception.h" 1 3
# 34 "/usr/include/c++/10/bits/exception.h" 3
# 35 "/usr/include/c++/10/bits/exception.h" 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
# 60 "/usr/include/c++/10/bits/exception.h" 3
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
exception(const exception&) = default;
exception& operator=(const exception&) = default;
exception(exception&&) = default;
exception& operator=(exception&&) = default;
virtual const char*
what() const noexcept;
};
}
}
#pragma GCC visibility pop
# 39 "/usr/include/c++/10/exception" 2 3
extern "C++" {
namespace std
{
class bad_exception : public exception
{
public:
bad_exception() noexcept { }
virtual ~bad_exception() noexcept;
virtual const char*
what() const noexcept;
};
typedef void (*terminate_handler) ();
typedef void (*unexpected_handler) ();
terminate_handler set_terminate(terminate_handler) noexcept;
terminate_handler get_terminate() noexcept;
void terminate() noexcept __attribute__ ((__noreturn__));
unexpected_handler set_unexpected(unexpected_handler) noexcept;
unexpected_handler get_unexpected() noexcept;
void unexpected() __attribute__ ((__noreturn__));
# 105 "/usr/include/c++/10/exception" 3
bool uncaught_exception() noexcept __attribute__ ((__pure__));
int uncaught_exceptions() noexcept __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
# 137 "/usr/include/c++/10/exception" 3
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
# 1 "/usr/include/c++/10/bits/exception_ptr.h" 1 3
# 34 "/usr/include/c++/10/bits/exception_ptr.h" 3
#pragma GCC visibility push(default)
# 1 "/usr/include/c++/10/bits/exception_defines.h" 1 3
# 38 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 1 3
# 34 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
# 35 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
#pragma GCC visibility push(default)
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 39 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 2 3
# 50 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
namespace std
{
class type_info;
}
namespace __cxxabiv1
{
struct __cxa_refcounted_exception;
extern "C"
{
void*
__cxa_allocate_exception(size_t) noexcept;
void
__cxa_free_exception(void*) noexcept;
__cxa_refcounted_exception*
__cxa_init_primary_exception(void *object, std::type_info *tinfo,
void ( *dest) (void *)) noexcept;
}
}
#pragma GCC visibility pop
# 39 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/typeinfo" 1 3
# 32 "/usr/include/c++/10/typeinfo" 3
# 33 "/usr/include/c++/10/typeinfo" 3
# 1 "/usr/include/c++/10/bits/hash_bytes.h" 1 3
# 33 "/usr/include/c++/10/bits/hash_bytes.h" 3
# 34 "/usr/include/c++/10/bits/hash_bytes.h" 3
namespace std
{
size_t
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
size_t
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
}
# 37 "/usr/include/c++/10/typeinfo" 2 3
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
# 80 "/usr/include/c++/10/typeinfo" 3
namespace std
{
class type_info
{
public:
virtual ~type_info();
const char* name() const noexcept
{ return __name[0] == '*' ? __name + 1 : __name; }
# 115 "/usr/include/c++/10/typeinfo" 3
bool before(const type_info& __arg) const noexcept
{ return (__name[0] == '*' && __arg.__name[0] == '*')
? __name < __arg.__name
: __builtin_strcmp (__name, __arg.__name) < 0; }
bool operator==(const type_info& __arg) const noexcept
{
return ((__name == __arg.__name)
|| (__name[0] != '*' &&
__builtin_strcmp (__name, __arg.__name) == 0));
}
# 138 "/usr/include/c++/10/typeinfo" 3
bool operator!=(const type_info& __arg) const noexcept
{ return !operator==(__arg); }
size_t hash_code() const noexcept
{
return _Hash_bytes(name(), __builtin_strlen(name()),
static_cast<size_t>(0xc70f6907UL));
}
virtual bool __is_pointer_p() const;
virtual bool __is_function_p() const;
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
unsigned __outer) const;
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
protected:
const char *__name;
explicit type_info(const char *__n): __name(__n) { }
private:
type_info& operator=(const type_info&);
type_info(const type_info&);
};
class bad_cast : public exception
{
public:
bad_cast() noexcept { }
virtual ~bad_cast() noexcept;
virtual const char* what() const noexcept;
};
class bad_typeid : public exception
{
public:
bad_typeid () noexcept { }
virtual ~bad_typeid() noexcept;
virtual const char* what() const noexcept;
};
}
}
#pragma GCC visibility pop
# 40 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/new" 1 3
# 41 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
extern "C++" {
namespace std
{
class type_info;
namespace __exception_ptr
{
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
template<typename _Ex>
exception_ptr make_exception_ptr(_Ex) noexcept;
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
namespace __exception_ptr
{
using std::rethrow_exception;
class exception_ptr
{
void* _M_exception_object;
explicit exception_ptr(void* __e) noexcept;
void _M_addref() noexcept;
void _M_release() noexcept;
void *_M_get() const noexcept __attribute__ ((__pure__));
friend exception_ptr std::current_exception() noexcept;
friend void std::rethrow_exception(exception_ptr);
template<typename _Ex>
friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
public:
exception_ptr() noexcept;
exception_ptr(const exception_ptr&) noexcept;
exception_ptr(nullptr_t) noexcept
: _M_exception_object(0)
{ }
exception_ptr(exception_ptr&& __o) noexcept
: _M_exception_object(__o._M_exception_object)
{ __o._M_exception_object = 0; }
# 118 "/usr/include/c++/10/bits/exception_ptr.h" 3
exception_ptr&
operator=(const exception_ptr&) noexcept;
exception_ptr&
operator=(exception_ptr&& __o) noexcept
{
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
return *this;
}
~exception_ptr() noexcept;
void
swap(exception_ptr&) noexcept;
# 145 "/usr/include/c++/10/bits/exception_ptr.h" 3
explicit operator bool() const
{ return _M_exception_object; }
friend bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
const class std::type_info*
__cxa_exception_type() const noexcept
__attribute__ ((__pure__));
};
bool
operator==(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
bool
operator!=(const exception_ptr&, const exception_ptr&)
noexcept __attribute__ ((__pure__));
inline void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
{ __lhs.swap(__rhs); }
template<typename _Ex>
inline void
__dest_thunk(void* __x)
{ static_cast<_Ex*>(__x)->~_Ex(); }
}
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
# 213 "/usr/include/c++/10/bits/exception_ptr.h" 3
return exception_ptr();
}
}
}
#pragma GCC visibility pop
# 148 "/usr/include/c++/10/exception" 2 3
# 1 "/usr/include/c++/10/bits/nested_exception.h" 1 3
# 33 "/usr/include/c++/10/bits/nested_exception.h" 3
#pragma GCC visibility push(default)
# 1 "/usr/include/c++/10/bits/move.h" 1 3
# 38 "/usr/include/c++/10/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline constexpr _Tp*
__addressof(_Tp& __r) noexcept
{ return __builtin_addressof(__r); }
}
# 1 "/usr/include/c++/10/type_traits" 1 3
# 32 "/usr/include/c++/10/type_traits" 3
# 33 "/usr/include/c++/10/type_traits" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/usr/include/c++/10/type_traits" 3
template<typename _Tp, _Tp __v>
struct integral_constant
{
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const noexcept { return value; }
constexpr value_type operator()() const noexcept { return value; }
};
template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template<bool __v>
using __bool_constant = integral_constant<bool, __v>;
# 91 "/usr/include/c++/10/type_traits" 3
template<bool, typename, typename>
struct conditional;
template <typename _Type>
struct __type_identity
{ using type = _Type; };
template<typename _Tp>
using __type_identity_t = typename __type_identity<_Tp>::type;
template<typename...>
struct __or_;
template<>
struct __or_<>
: public false_type
{ };
template<typename _B1>
struct __or_<_B1>
: public _B1
{ };
template<typename _B1, typename _B2>
struct __or_<_B1, _B2>
: public conditional<_B1::value, _B1, _B2>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
{ };
template<typename...>
struct __and_;
template<>
struct __and_<>
: public true_type
{ };
template<typename _B1>
struct __and_<_B1>
: public _B1
{ };
template<typename _B1, typename _B2>
struct __and_<_B1, _B2>
: public conditional<_B1::value, _B2, _B1>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
{ };
template<typename _Pp>
struct __not_
: public __bool_constant<!bool(_Pp::value)>
{ };
# 188 "/usr/include/c++/10/type_traits" 3
template<typename>
struct is_reference;
template<typename>
struct is_function;
template<typename>
struct is_void;
template<typename>
struct __is_array_unknown_bounds;
template <typename _Tp, size_t = sizeof(_Tp)>
constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
{ return {}; }
template <typename _TypeIdentity,
typename _NestedType = typename _TypeIdentity::type>
constexpr typename __or_<
is_reference<_NestedType>,
is_function<_NestedType>,
is_void<_NestedType>,
__is_array_unknown_bounds<_NestedType>
>::type __is_complete_or_unbounded(_TypeIdentity)
{ return {}; }
template<typename _Tp>
struct __success_type
{ typedef _Tp type; };
struct __failure_type
{ };
template<typename>
struct remove_cv;
template<typename _Tp>
using __remove_cv_t = typename remove_cv<_Tp>::type;
template<typename>
struct is_const;
template<typename>
struct __is_void_helper
: public false_type { };
template<>
struct __is_void_helper<void>
: public true_type { };
template<typename _Tp>
struct is_void
: public __is_void_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct __is_integral_helper
: public false_type { };
template<>
struct __is_integral_helper<bool>
: public true_type { };
template<>
struct __is_integral_helper<char>
: public true_type { };
template<>
struct __is_integral_helper<signed char>
: public true_type { };
template<>
struct __is_integral_helper<unsigned char>
: public true_type { };
template<>
struct __is_integral_helper<wchar_t>
: public true_type { };
# 284 "/usr/include/c++/10/type_traits" 3
template<>
struct __is_integral_helper<char16_t>
: public true_type { };
template<>
struct __is_integral_helper<char32_t>
: public true_type { };
template<>
struct __is_integral_helper<short>
: public true_type { };
template<>
struct __is_integral_helper<unsigned short>
: public true_type { };
template<>
struct __is_integral_helper<int>
: public true_type { };
template<>
struct __is_integral_helper<unsigned int>
: public true_type { };
template<>
struct __is_integral_helper<long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long>
: public true_type { };
template<>
struct __is_integral_helper<long long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };
template<>
struct __is_integral_helper<__int128>
: public true_type { };
template<>
struct __is_integral_helper<unsigned __int128>
: public true_type { };
# 364 "/usr/include/c++/10/type_traits" 3
template<typename _Tp>
struct is_integral
: public __is_integral_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct __is_floating_point_helper
: public false_type { };
template<>
struct __is_floating_point_helper<float>
: public true_type { };
template<>
struct __is_floating_point_helper<double>
: public true_type { };
template<>
struct __is_floating_point_helper<long double>
: public true_type { };
template<>
struct __is_floating_point_helper<__float128>
: public true_type { };
template<typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct is_array
: public false_type { };
template<typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]>
: public true_type { };
template<typename _Tp>
struct is_array<_Tp[]>
: public true_type { };
template<typename>
struct __is_pointer_helper
: public false_type { };
template<typename _Tp>
struct __is_pointer_helper<_Tp*>
: public true_type { };
template<typename _Tp>
struct is_pointer
: public __is_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct is_lvalue_reference
: public false_type { };
template<typename _Tp>
struct is_lvalue_reference<_Tp&>
: public true_type { };
template<typename>
struct is_rvalue_reference
: public false_type { };
template<typename _Tp>
struct is_rvalue_reference<_Tp&&>
: public true_type { };
template<typename>
struct __is_member_object_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<_Tp _Cp::*>
: public __not_<is_function<_Tp>>::type { };
template<typename _Tp>
struct is_member_object_pointer
: public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename>
struct __is_member_function_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<_Tp _Cp::*>
: public is_function<_Tp>::type { };
template<typename _Tp>
struct is_member_function_pointer
: public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename _Tp>
struct is_enum
: public integral_constant<bool, __is_enum(_Tp)>
{ };
template<typename _Tp>
struct is_union
: public integral_constant<bool, __is_union(_Tp)>
{ };
template<typename _Tp>
struct is_class
: public integral_constant<bool, __is_class(_Tp)>
{ };
template<typename _Tp>
struct is_function
: public __bool_constant<!is_const<const _Tp>::value> { };
template<typename _Tp>
struct is_function<_Tp&>
: public false_type { };
template<typename _Tp>
struct is_function<_Tp&&>
: public false_type { };
template<typename>
struct __is_null_pointer_helper
: public false_type { };
template<>
struct __is_null_pointer_helper<std::nullptr_t>
: public true_type { };
template<typename _Tp>
struct is_null_pointer
: public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename _Tp>
struct __is_nullptr_t
: public is_null_pointer<_Tp>
{ } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead")));
template<typename _Tp>
struct is_reference
: public __or_<is_lvalue_reference<_Tp>,
is_rvalue_reference<_Tp>>::type
{ };
template<typename _Tp>
struct is_arithmetic
: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
{ };
template<typename _Tp>
struct is_fundamental
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp>>::type
{ };
template<typename _Tp>
struct is_object
: public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
is_void<_Tp>>>::type
{ };
template<typename>
struct is_member_pointer;
template<typename _Tp>
struct is_scalar
: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
{ };
template<typename _Tp>
struct is_compound
: public __not_<is_fundamental<_Tp>>::type { };
template<typename _Tp>
struct __is_member_pointer_helper
: public false_type { };
template<typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*>
: public true_type { };
template<typename _Tp>
struct is_member_pointer
: public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
{ };
template<typename, typename>
struct is_same;
template<typename _Tp, typename... _Types>
using __is_one_of = __or_<is_same<_Tp, _Types>...>;
template<typename _Tp>
using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
signed char, signed short, signed int, signed long,
signed long long
, signed __int128
# 604 "/usr/include/c++/10/type_traits" 3
>;
template<typename _Tp>
using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
unsigned char, unsigned short, unsigned int, unsigned long,
unsigned long long
, unsigned __int128
# 623 "/usr/include/c++/10/type_traits" 3
>;
template<typename _Tp>
using __is_standard_integer
= __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
template<typename...> using __void_t = void;
template<typename _Tp, typename = void>
struct __is_referenceable
: public false_type
{ };
template<typename _Tp>
struct __is_referenceable<_Tp, __void_t<_Tp&>>
: public true_type
{ };
template<typename>
struct is_const
: public false_type { };
template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };
template<typename>
struct is_volatile
: public false_type { };
template<typename _Tp>
struct is_volatile<_Tp volatile>
: public true_type { };
template<typename _Tp>
struct is_trivial
: public integral_constant<bool, __is_trivial(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct
is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_final
: public integral_constant<bool, __is_final(_Tp)>
{ };
template<typename _Tp>
struct is_abstract
: public integral_constant<bool, __is_abstract(_Tp)>
{ };
template<typename _Tp,
bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper
: public false_type { };
template<typename _Tp>
struct __is_signed_helper<_Tp, true>
: public integral_constant<bool, _Tp(-1) < _Tp(0)>
{ };
template<typename _Tp>
struct is_signed
: public __is_signed_helper<_Tp>::type
{ };
template<typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
{ };
# 770 "/usr/include/c++/10/type_traits" 3
template<typename _Tp, typename _Up = _Tp&&>
_Up
__declval(int);
template<typename _Tp>
_Tp
__declval(long);
template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0));
template<typename, unsigned = 0>
struct extent;
template<typename>
struct remove_all_extents;
template<typename _Tp>
struct __is_array_known_bounds
: public integral_constant<bool, (extent<_Tp>::value > 0)>
{ };
template<typename _Tp>
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
{ };
struct __do_is_destructible_impl
{
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_destructible_impl
: public __do_is_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_destructible_safe;
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, false>
: public __is_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_destructible_safe<_Tp, true, false>
: public false_type { };
template<typename _Tp>
struct __is_destructible_safe<_Tp, false, true>
: public true_type { };
template<typename _Tp>
struct is_destructible
: public __is_destructible_safe<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
struct __do_is_nt_destructible_impl
{
template<typename _Tp>
static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
__test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_nt_destructible_impl
: public __do_is_nt_destructible_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_nt_destructible_safe;
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, false>
: public __is_nt_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, true, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true>
: public true_type { };
template<typename _Tp>
struct is_nothrow_destructible
: public __is_nt_destructible_safe<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename... _Args>
struct __is_constructible_impl
: public __bool_constant<__is_constructible(_Tp, _Args...)>
{ };
template<typename _Tp, typename... _Args>
struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_default_constructible
: public __is_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_constructible_impl;
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_copy_constructible_impl<_Tp, true>
: public __is_constructible_impl<_Tp, const _Tp&>
{ };
template<typename _Tp>
struct is_copy_constructible
: public __is_copy_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_constructible_impl;
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_move_constructible_impl<_Tp, true>
: public __is_constructible_impl<_Tp, _Tp&&>
{ };
template<typename _Tp>
struct is_move_constructible
: public __is_move_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<bool, typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
: public false_type
{ };
template<typename _Tp, typename... _Args>
struct __is_nt_constructible_impl<true, _Tp, _Args...>
: public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
{ };
template<typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<true, _Tp, _Arg>
: public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
{ };
template<typename _Tp>
struct __is_nt_constructible_impl<true, _Tp>
: public __bool_constant<noexcept(_Tp())>
{ };
template<typename _Tp, size_t _Num>
struct __is_nt_constructible_impl<true, _Tp[_Num]>
: public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
{ };
# 1001 "/usr/include/c++/10/type_traits" 3
template<typename _Tp, typename... _Args>
using __is_nothrow_constructible_impl
= __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
_Tp, _Args...>;
template<typename _Tp, typename... _Args>
struct is_nothrow_constructible
: public __is_nothrow_constructible_impl<_Tp, _Args...>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_nothrow_default_constructible
: public __is_nothrow_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_copy_constructible_impl;
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, true>
: public __is_nothrow_constructible_impl<_Tp, const _Tp&>
{ };
template<typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_move_constructible_impl;
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, true>
: public __is_nothrow_constructible_impl<_Tp, _Tp&&>
{ };
template<typename _Tp>
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up>
struct is_assignable
: public __bool_constant<__is_assignable(_Tp, _Up)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_assignable_impl;
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_copy_assignable_impl<_Tp, true>
: public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
{ };
template<typename _Tp>
struct is_copy_assignable
: public __is_copy_assignable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_assignable_impl;
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_move_assignable_impl<_Tp, true>
: public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
{ };
template<typename _Tp>
struct is_move_assignable
: public __is_move_assignable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up>
struct __is_nt_assignable_impl
: public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
{ };
template<typename _Tp, typename _Up>
struct __is_nothrow_assignable_impl
: public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
__is_nt_assignable_impl<_Tp, _Up>>
{ };
template<typename _Tp, typename _Up>
struct is_nothrow_assignable
: public __is_nothrow_assignable_impl<_Tp, _Up>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_copy_assignable_impl;
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true>
: public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
{ };
template<typename _Tp>
struct is_nothrow_copy_assignable
: public __is_nt_copy_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_move_assignable_impl;
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true>
: public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
{ };
template<typename _Tp>
struct is_nothrow_move_assignable
: public __is_nt_move_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename... _Args>
struct is_trivially_constructible
: public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_trivially_default_constructible
: public __bool_constant<__is_trivially_constructible(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
struct __do_is_implicitly_default_constructible_impl
{
template <typename _Tp>
static void __helper(const _Tp&);
template <typename _Tp>
static true_type __test(const _Tp&,
decltype(__helper<const _Tp&>({}))* = 0);
static false_type __test(...);
};
template<typename _Tp>
struct __is_implicitly_default_constructible_impl
: public __do_is_implicitly_default_constructible_impl
{
typedef decltype(__test(declval<_Tp>())) type;
};
template<typename _Tp>
struct __is_implicitly_default_constructible_safe
: public __is_implicitly_default_constructible_impl<_Tp>::type
{ };
template <typename _Tp>
struct __is_implicitly_default_constructible
: public __and_<__is_constructible_impl<_Tp>,
__is_implicitly_default_constructible_safe<_Tp>>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_copy_constructible_impl;
template<typename _Tp>
struct __is_trivially_copy_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_copy_constructible_impl<_Tp, true>
: public __and_<__is_copy_constructible_impl<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, const _Tp&)>>
{ };
template<typename _Tp>
struct is_trivially_copy_constructible
: public __is_trivially_copy_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_move_constructible_impl;
template<typename _Tp>
struct __is_trivially_move_constructible_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_move_constructible_impl<_Tp, true>
: public __and_<__is_move_constructible_impl<_Tp>,
integral_constant<bool,
__is_trivially_constructible(_Tp, _Tp&&)>>
{ };
template<typename _Tp>
struct is_trivially_move_constructible
: public __is_trivially_move_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up>
struct is_trivially_assignable
: public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_copy_assignable_impl;
template<typename _Tp>
struct __is_trivially_copy_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_copy_assignable_impl<_Tp, true>
: public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
{ };
template<typename _Tp>
struct is_trivially_copy_assignable
: public __is_trivially_copy_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_trivially_move_assignable_impl;
template<typename _Tp>
struct __is_trivially_move_assignable_impl<_Tp, false>
: public false_type { };
template<typename _Tp>
struct __is_trivially_move_assignable_impl<_Tp, true>
: public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
{ };
template<typename _Tp>
struct is_trivially_move_assignable
: public __is_trivially_move_assignable_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_trivially_destructible
: public __and_<__is_destructible_safe<_Tp>,
__bool_constant<__has_trivial_destructor(_Tp)>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, alignof(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, typename _Up>
struct is_same
: public integral_constant<bool, __is_same_as(_Tp, _Up)>
{ };
# 1410 "/usr/include/c++/10/type_traits" 3
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_convertible_helper
{
typedef typename is_void<_To>::type type;
};
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1) noexcept;
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
#pragma GCC diagnostic pop
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
template<typename _ToElementType, typename _FromElementType>
using __is_array_convertible
= is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_nt_convertible_helper
: is_void<_To>
{ };
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
template<typename _From, typename _To>
class __is_nt_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1) noexcept;
template<typename _From1, typename _To1>
static
__bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
using type = decltype(__test<_From, _To>(0));
};
#pragma GCC diagnostic pop
template<typename _From, typename _To>
struct __is_nothrow_convertible
: public __is_nt_convertible_helper<_From, _To>::type
{ };
# 1508 "/usr/include/c++/10/type_traits" 3
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_cv
{ using type = _Tp; };
template<typename _Tp>
struct remove_cv<const _Tp>
{ using type = _Tp; };
template<typename _Tp>
struct remove_cv<volatile _Tp>
{ using type = _Tp; };
template<typename _Tp>
struct remove_cv<const volatile _Tp>
{ using type = _Tp; };
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
using remove_const_t = typename remove_const<_Tp>::type;
template<typename _Tp>
using remove_volatile_t = typename remove_volatile<_Tp>::type;
template<typename _Tp>
using remove_cv_t = typename remove_cv<_Tp>::type;
template<typename _Tp>
using add_const_t = typename add_const<_Tp>::type;
template<typename _Tp>
using add_volatile_t = typename add_volatile<_Tp>::type;
template<typename _Tp>
using add_cv_t = typename add_cv<_Tp>::type;
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
template<typename _Tp>
using remove_reference_t = typename remove_reference<_Tp>::type;
template<typename _Tp>
using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
template<typename _Tp>
using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
template<typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __make_unsigned<__int128>
{ typedef unsigned __int128 __type; };
# 1730 "/usr/include/c++/10/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector;
template<typename _Tp>
class __make_unsigned_selector<_Tp, true, false>
{
using __unsigned_type
= typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
public:
using __type
= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
};
class __make_unsigned_selector_base
{
protected:
template<typename...> struct _List { };
template<typename _Tp, typename... _Up>
struct _List<_Tp, _Up...> : _List<_Up...>
{ static constexpr size_t __size = sizeof(_Tp); };
template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
struct __select;
template<size_t _Sz, typename _Uint, typename... _UInts>
struct __select<_Sz, _List<_Uint, _UInts...>, true>
{ using __type = _Uint; };
template<size_t _Sz, typename _Uint, typename... _UInts>
struct __select<_Sz, _List<_Uint, _UInts...>, false>
: __select<_Sz, _List<_UInts...>>
{ };
};
template<typename _Tp>
class __make_unsigned_selector<_Tp, false, true>
: __make_unsigned_selector_base
{
using _UInts = _List<unsigned char, unsigned short, unsigned int,
unsigned long, unsigned long long>;
using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
public:
using __type
= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
};
template<>
struct __make_unsigned<wchar_t>
{
using __type
= typename __make_unsigned_selector<wchar_t, false, true>::__type;
};
# 1806 "/usr/include/c++/10/type_traits" 3
template<>
struct __make_unsigned<char16_t>
{
using __type
= typename __make_unsigned_selector<char16_t, false, true>::__type;
};
template<>
struct __make_unsigned<char32_t>
{
using __type
= typename __make_unsigned_selector<char32_t, false, true>::__type;
};
template<typename _Tp>
struct make_unsigned
{ typedef typename __make_unsigned_selector<_Tp>::__type type; };
template<>
struct make_unsigned<bool>;
template<typename _Tp>
struct __make_signed
{ typedef _Tp __type; };
template<>
struct __make_signed<char>
{ typedef signed char __type; };
template<>
struct __make_signed<unsigned char>
{ typedef signed char __type; };
template<>
struct __make_signed<unsigned short>
{ typedef signed short __type; };
template<>
struct __make_signed<unsigned int>
{ typedef signed int __type; };
template<>
struct __make_signed<unsigned long>
{ typedef signed long __type; };
template<>
struct __make_signed<unsigned long long>
{ typedef signed long long __type; };
template<>
struct __make_signed<unsigned __int128>
{ typedef __int128 __type; };
# 1884 "/usr/include/c++/10/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector;
template<typename _Tp>
class __make_signed_selector<_Tp, true, false>
{
using __signed_type
= typename __make_signed<__remove_cv_t<_Tp>>::__type;
public:
using __type
= typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
};
template<typename _Tp>
class __make_signed_selector<_Tp, false, true>
{
typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
public:
typedef typename __make_signed_selector<__unsigned_type>::__type __type;
};
template<>
struct __make_signed<wchar_t>
{
using __type
= typename __make_signed_selector<wchar_t, false, true>::__type;
};
# 1932 "/usr/include/c++/10/type_traits" 3
template<>
struct __make_signed<char16_t>
{
using __type
= typename __make_signed_selector<char16_t, false, true>::__type;
};
template<>
struct __make_signed<char32_t>
{
using __type
= typename __make_signed_selector<char32_t, false, true>::__type;
};
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
template<>
struct make_signed<bool>;
template<typename _Tp>
using make_signed_t = typename make_signed<_Tp>::type;
template<typename _Tp>
using make_unsigned_t = typename make_unsigned<_Tp>::type;
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
using remove_extent_t = typename remove_extent<_Tp>::type;
template<typename _Tp>
using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
{ };
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<typename _Tp>
using remove_pointer_t = typename remove_pointer<_Tp>::type;
template<typename _Tp>
using add_pointer_t = typename add_pointer<_Tp>::type;
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
# 2067 "/usr/include/c++/10/type_traits" 3
template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
template <typename... _Types>
struct __strictest_alignment
{
static const size_t _S_alignment = 0;
static const size_t _S_size = 0;
};
template <typename _Tp, typename... _Types>
struct __strictest_alignment<_Tp, _Types...>
{
static const size_t _S_alignment =
alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
static const size_t _S_size =
sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
};
# 2106 "/usr/include/c++/10/type_traits" 3
template <size_t _Len, typename... _Types>
struct aligned_union
{
private:
static_assert(sizeof...(_Types) != 0, "At least one type is required");
using __strictest = __strictest_alignment<_Types...>;
static const size_t _S_len = _Len > __strictest::_S_size
? _Len : __strictest::_S_size;
public:
static const size_t alignment_value = __strictest::_S_alignment;
typedef typename aligned_storage<_S_len, alignment_value>::type type;
};
template <size_t _Len, typename... _Types>
const size_t aligned_union<_Len, _Types...>::alignment_value;
template<typename _Up,
bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef __remove_cv_t<_Up> __type; };
template<typename _Up>
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
template<typename _Up>
struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; };
template<typename _Tp>
class decay
{
typedef typename remove_reference<_Tp>::type __remove_type;
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
template<typename _Tp>
using __decay_t = typename decay<_Tp>::type;
template<typename _Tp>
class reference_wrapper;
template<typename _Tp>
struct __strip_reference_wrapper
{
typedef _Tp __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename _Tp>
using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
template<bool, typename _Tp = void>
struct enable_if
{ };
template<typename _Tp>
struct enable_if<true, _Tp>
{ typedef _Tp type; };
template<bool _Cond, typename _Tp = void>
using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<typename... _Cond>
using _Require = __enable_if_t<__and_<_Cond...>::value>;
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional
{ typedef _Iftrue type; };
template<typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{ typedef _Iffalse type; };
template<typename _Tp>
using __remove_cvref_t
= typename remove_cv<typename remove_reference<_Tp>::type>::type;
template<typename... _Tp>
struct common_type;
struct __do_common_type_impl
{
template<typename _Tp, typename _Up>
using __cond_t
= decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
template<typename _Tp, typename _Up>
static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
_S_test(int);
# 2239 "/usr/include/c++/10/type_traits" 3
template<typename, typename>
static __failure_type
_S_test_2(...);
template<typename _Tp, typename _Up>
static decltype(_S_test_2<_Tp, _Up>(0))
_S_test(...);
};
template<>
struct common_type<>
{ };
template<typename _Tp0>
struct common_type<_Tp0>
: public common_type<_Tp0, _Tp0>
{ };
template<typename _Tp1, typename _Tp2,
typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
struct __common_type_impl
{
using type = common_type<_Dp1, _Dp2>;
};
template<typename _Tp1, typename _Tp2>
struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
: private __do_common_type_impl
{
using type = decltype(_S_test<_Tp1, _Tp2>(0));
};
template<typename _Tp1, typename _Tp2>
struct common_type<_Tp1, _Tp2>
: public __common_type_impl<_Tp1, _Tp2>::type
{ };
template<typename...>
struct __common_type_pack
{ };
template<typename, typename, typename = void>
struct __common_type_fold;
template<typename _Tp1, typename _Tp2, typename... _Rp>
struct common_type<_Tp1, _Tp2, _Rp...>
: public __common_type_fold<common_type<_Tp1, _Tp2>,
__common_type_pack<_Rp...>>
{ };
template<typename _CTp, typename... _Rp>
struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
__void_t<typename _CTp::type>>
: public common_type<typename _CTp::type, _Rp...>
{ };
template<typename _CTp, typename _Rp>
struct __common_type_fold<_CTp, _Rp, void>
{ };
template<typename _Tp, bool = is_enum<_Tp>::value>
struct __underlying_type_impl
{
using type = __underlying_type(_Tp);
};
template<typename _Tp>
struct __underlying_type_impl<_Tp, false>
{ };
template<typename _Tp>
struct underlying_type
: public __underlying_type_impl<_Tp>
{ };
template<typename _Tp>
struct __declval_protector
{
static const bool __stop = false;
};
template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0))
{
static_assert(__declval_protector<_Tp>::__stop,
"declval() must not be used!");
return __declval<_Tp>(0);
}
template<typename _Signature>
class result_of;
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };
template<typename _Tp, typename _Tag>
struct __result_of_success : __success_type<_Tp>
{ using __invoke_type = _Tag; };
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_ref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_ref
: private __result_of_memfun_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memfun_deref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_deref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_deref
: private __result_of_memfun_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memobj_ref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
), __invoke_memobj_ref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
struct __result_of_memobj_deref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
), __invoke_memobj_deref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj;
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, _Arg>
{
typedef __remove_cvref_t<_Arg> _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg>
>::type::type type;
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun;
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
{
typedef typename remove_reference<_Arg>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<is_base_of<_Class, _Argval>::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...>
>::type::type type;
};
template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
struct __inv_unwrap
{
using type = _Tp;
};
template<typename _Tp, typename _Up>
struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
{
using type = _Up&;
};
template<bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl
{
typedef __failure_type type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_impl<true, false, _MemPtr, _Arg>
: public __result_of_memobj<__decay_t<_MemPtr>,
typename __inv_unwrap<_Arg>::type>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<__decay_t<_MemPtr>,
typename __inv_unwrap<_Arg>::type, _Args...>
{ };
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __result_of_success<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
), __invoke_other> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor, _ArgTypes...>
: private __result_of_other_impl
{
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
template<typename _Functor, typename... _ArgTypes>
struct __invoke_result
: public __result_of_impl<
is_member_object_pointer<
typename remove_reference<_Functor>::type
>::value,
is_member_function_pointer<
typename remove_reference<_Functor>::type
>::value,
_Functor, _ArgTypes...
>::type
{ };
template<typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)>
: public __invoke_result<_Functor, _ArgTypes...>
{ };
template<size_t _Len, size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
template <size_t _Len, typename... _Types>
using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
template<typename _Tp>
using decay_t = typename decay<_Tp>::type;
template<bool _Cond, typename _Tp = void>
using enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<bool _Cond, typename _Iftrue, typename _Iffalse>
using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
template<typename... _Tp>
using common_type_t = typename common_type<_Tp...>::type;
template<typename _Tp>
using underlying_type_t = typename underlying_type<_Tp>::type;
template<typename _Tp>
using result_of_t = typename result_of<_Tp>::type;
template<typename...> using void_t = void;
template<typename _Default, typename _AlwaysVoid,
template<typename...> class _Op, typename... _Args>
struct __detector
{
using value_t = false_type;
using type = _Default;
};
template<typename _Default, template<typename...> class _Op,
typename... _Args>
struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
{
using value_t = true_type;
using type = _Op<_Args...>;
};
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or = __detector<_Default, void, _Op, _Args...>;
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or_t
= typename __detected_or<_Default, _Op, _Args...>::type;
# 2624 "/usr/include/c++/10/type_traits" 3
template <typename _Tp>
struct __is_swappable;
template <typename _Tp>
struct __is_nothrow_swappable;
template<typename... _Elements>
class tuple;
template<typename>
struct __is_tuple_like_impl : false_type
{ };
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
{ };
template<typename _Tp>
inline
_Require<__not_<__is_tuple_like<_Tp>>,
is_move_constructible<_Tp>,
is_move_assignable<_Tp>>
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value);
template<typename _Tp, size_t _Nm>
inline
__enable_if_t<__is_swappable<_Tp>::value>
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value);
namespace __swappable_details {
using std::swap;
struct __do_is_swappable_impl
{
template<typename _Tp, typename
= decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
struct __do_is_nothrow_swappable_impl
{
template<typename _Tp>
static __bool_constant<
noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> __test(int);
template<typename>
static false_type __test(...);
};
}
template<typename _Tp>
struct __is_swappable_impl
: public __swappable_details::__do_is_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_nothrow_swappable_impl
: public __swappable_details::__do_is_nothrow_swappable_impl
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp>
struct __is_swappable
: public __is_swappable_impl<_Tp>::type
{ };
template<typename _Tp>
struct __is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{ };
template<typename _Tp>
struct is_swappable
: public __is_swappable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
struct is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp>
constexpr bool is_swappable_v =
is_swappable<_Tp>::value;
template<typename _Tp>
constexpr bool is_nothrow_swappable_v =
is_nothrow_swappable<_Tp>::value;
namespace __swappable_with_details {
using std::swap;
struct __do_is_swappable_with_impl
{
template<typename _Tp, typename _Up, typename
= decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
typename
= decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
static true_type __test(int);
template<typename, typename>
static false_type __test(...);
};
struct __do_is_nothrow_swappable_with_impl
{
template<typename _Tp, typename _Up>
static __bool_constant<
noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
&&
noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
> __test(int);
template<typename, typename>
static false_type __test(...);
};
}
template<typename _Tp, typename _Up>
struct __is_swappable_with_impl
: public __swappable_with_details::__do_is_swappable_with_impl
{
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template<typename _Tp>
struct __is_swappable_with_impl<_Tp&, _Tp&>
: public __swappable_details::__do_is_swappable_impl
{
typedef decltype(__test<_Tp&>(0)) type;
};
template<typename _Tp, typename _Up>
struct __is_nothrow_swappable_with_impl
: public __swappable_with_details::__do_is_nothrow_swappable_with_impl
{
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template<typename _Tp>
struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
: public __swappable_details::__do_is_nothrow_swappable_impl
{
typedef decltype(__test<_Tp&>(0)) type;
};
template<typename _Tp, typename _Up>
struct is_swappable_with
: public __is_swappable_with_impl<_Tp, _Up>::type
{ };
template<typename _Tp, typename _Up>
struct is_nothrow_swappable_with
: public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
{ };
template<typename _Tp, typename _Up>
constexpr bool is_swappable_with_v =
is_swappable_with<_Tp, _Up>::value;
template<typename _Tp, typename _Up>
constexpr bool is_nothrow_swappable_with_v =
is_nothrow_swappable_with<_Tp, _Up>::value;
template<typename _Result, typename _Ret,
bool = is_void<_Ret>::value, typename = void>
struct __is_invocable_impl : false_type { };
template<typename _Result, typename _Ret>
struct __is_invocable_impl<_Result, _Ret,
true,
__void_t<typename _Result::type>>
: true_type
{ };
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
template<typename _Result, typename _Ret>
struct __is_invocable_impl<_Result, _Ret,
false,
__void_t<typename _Result::type>>
{
private:
static typename _Result::type _S_get();
template<typename _Tp>
static void _S_conv(_Tp);
template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
static true_type
_S_test(int);
template<typename _Tp>
static false_type
_S_test(...);
public:
using type = decltype(_S_test<_Ret>(1));
};
#pragma GCC diagnostic pop
template<typename _Fn, typename... _ArgTypes>
struct __is_invocable
: __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
{ };
template<typename _Fn, typename _Tp, typename... _Args>
constexpr bool __call_is_nt(__invoke_memfun_ref)
{
using _Up = typename __inv_unwrap<_Tp>::type;
return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
std::declval<_Args>()...));
}
template<typename _Fn, typename _Tp, typename... _Args>
constexpr bool __call_is_nt(__invoke_memfun_deref)
{
return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
std::declval<_Args>()...));
}
template<typename _Fn, typename _Tp>
constexpr bool __call_is_nt(__invoke_memobj_ref)
{
using _Up = typename __inv_unwrap<_Tp>::type;
return noexcept(std::declval<_Up>().*std::declval<_Fn>());
}
template<typename _Fn, typename _Tp>
constexpr bool __call_is_nt(__invoke_memobj_deref)
{
return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
}
template<typename _Fn, typename... _Args>
constexpr bool __call_is_nt(__invoke_other)
{
return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
}
template<typename _Result, typename _Fn, typename... _Args>
struct __call_is_nothrow
: __bool_constant<
std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
>
{ };
template<typename _Fn, typename... _Args>
using __call_is_nothrow_
= __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
template<typename _Fn, typename... _Args>
struct __is_nothrow_invocable
: __and_<__is_invocable<_Fn, _Args...>,
__call_is_nothrow_<_Fn, _Args...>>::type
{ };
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
struct __nonesuchbase {};
struct __nonesuch : private __nonesuchbase {
~__nonesuch() = delete;
__nonesuch(__nonesuch const&) = delete;
void operator=(__nonesuch const&) = delete;
};
#pragma GCC diagnostic pop
# 3455 "/usr/include/c++/10/type_traits" 3
}
# 58 "/usr/include/c++/10/bits/move.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp&&>(__t);
}
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
template<typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
is_copy_constructible<_Tp>>::type { };
# 118 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
constexpr typename
conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
move_if_noexcept(_Tp& __x) noexcept
{ return std::move(__x); }
# 138 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
inline _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }
template<typename _Tp>
const _Tp* addressof(const _Tp&&) = delete;
template <typename _Tp, typename _Up = _Tp>
inline _Tp
__exchange(_Tp& __obj, _Up&& __new_val)
{
_Tp __old_val = std::move(__obj);
__obj = std::forward<_Up>(__new_val);
return __old_val;
}
# 179 "/usr/include/c++/10/bits/move.h" 3
template<typename _Tp>
inline
typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
is_move_constructible<_Tp>,
is_move_assignable<_Tp>>::value>::type
swap(_Tp& __a, _Tp& __b)
noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)
{
_Tp __tmp = std::move(__a);
__a = std::move(__b);
__b = std::move(__tmp);
}
template<typename _Tp, size_t _Nm>
inline
typename enable_if<__is_swappable<_Tp>::value>::type
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value)
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
# 41 "/usr/include/c++/10/bits/nested_exception.h" 2 3
extern "C++" {
namespace std
{
class nested_exception
{
exception_ptr _M_ptr;
public:
nested_exception() noexcept : _M_ptr(current_exception()) { }
nested_exception(const nested_exception&) noexcept = default;
nested_exception& operator=(const nested_exception&) noexcept = default;
virtual ~nested_exception() noexcept;
[[noreturn]]
void
rethrow_nested() const
{
if (_M_ptr)
rethrow_exception(_M_ptr);
std::terminate();
}
exception_ptr
nested_ptr() const noexcept
{ return _M_ptr; }
};
template<typename _Except>
struct _Nested_exception : public _Except, public nested_exception
{
explicit _Nested_exception(const _Except& __ex)
: _Except(__ex)
{ }
explicit _Nested_exception(_Except&& __ex)
: _Except(static_cast<_Except&&>(__ex))
{ }
};
template<typename _Tp>
[[noreturn]]
inline void
__throw_with_nested_impl(_Tp&& __t, true_type)
{
using _Up = typename remove_reference<_Tp>::type;
throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
}
template<typename _Tp>
[[noreturn]]
inline void
__throw_with_nested_impl(_Tp&& __t, false_type)
{ throw std::forward<_Tp>(__t); }
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
using _Up = typename decay<_Tp>::type;
using _CopyConstructible
= __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
static_assert(_CopyConstructible::value,
"throw_with_nested argument must be CopyConstructible");
using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
__not_<is_base_of<nested_exception, _Up>>>;
std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
}
template<typename _Tp>
using __rethrow_if_nested_cond = typename enable_if<
__and_<is_polymorphic<_Tp>,
__or_<__not_<is_base_of<nested_exception, _Tp>>,
is_convertible<_Tp*, nested_exception*>>>::value
>::type;
template<typename _Ex>
inline __rethrow_if_nested_cond<_Ex>
__rethrow_if_nested_impl(const _Ex* __ptr)
{
if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
__ne_ptr->rethrow_nested();
}
inline void
__rethrow_if_nested_impl(const void*)
{ }
template<typename _Ex>
inline void
rethrow_if_nested(const _Ex& __ex)
{ std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
}
}
#pragma GCC visibility pop
# 149 "/usr/include/c++/10/exception" 2 3
# 42 "/usr/include/c++/10/new" 2 3
#pragma GCC visibility push(default)
extern "C++" {
namespace std
{
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
bad_alloc(const bad_alloc&) = default;
bad_alloc& operator=(const bad_alloc&) = default;
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
class bad_array_new_length : public bad_alloc
{
public:
bad_array_new_length() throw() { }
virtual ~bad_array_new_length() throw();
virtual const char* what() const throw();
};
struct nothrow_t
{
explicit nothrow_t() = default;
};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
# 126 "/usr/include/c++/10/new" 3
void* operator new(std::size_t)
__attribute__((__externally_visible__));
void* operator new[](std::size_t)
__attribute__((__externally_visible__));
void operator delete(void*) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*) noexcept
__attribute__((__externally_visible__));
void operator delete(void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, std::size_t) noexcept
__attribute__((__externally_visible__));
void* operator new(std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__, __malloc__));
void* operator new[](std::size_t, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__, __malloc__));
void operator delete(void*, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) noexcept
__attribute__((__externally_visible__));
# 174 "/usr/include/c++/10/new" 3
inline void* operator new(std::size_t, void* __p) noexcept
{ return __p; }
inline void* operator new[](std::size_t, void* __p) noexcept
{ return __p; }
inline void operator delete (void*, void*) noexcept { }
inline void operator delete[](void*, void*) noexcept { }
}
# 230 "/usr/include/c++/10/new" 3
#pragma GCC visibility pop
# 237 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/c++/10/utility" 1 3
# 58 "/usr/include/c++/10/utility" 3
# 59 "/usr/include/c++/10/utility" 3
# 69 "/usr/include/c++/10/utility" 3
# 1 "/usr/include/c++/10/bits/stl_relops.h" 1 3
# 67 "/usr/include/c++/10/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
# 85 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator!=(const _Tp& __x, const _Tp& __y)
{ return !(__x == __y); }
# 98 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator>(const _Tp& __x, const _Tp& __y)
{ return __y < __x; }
# 111 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator<=(const _Tp& __x, const _Tp& __y)
{ return !(__y < __x); }
# 124 "/usr/include/c++/10/bits/stl_relops.h" 3
template <class _Tp>
inline bool
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
}
}
# 70 "/usr/include/c++/10/utility" 2 3
# 1 "/usr/include/c++/10/bits/stl_pair.h" 1 3
# 69 "/usr/include/c++/10/bits/stl_pair.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 80 "/usr/include/c++/10/bits/stl_pair.h" 3
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
constexpr piecewise_construct_t piecewise_construct =
piecewise_construct_t();
template<typename...>
class tuple;
template<std::size_t...>
struct _Index_tuple;
template <bool, typename _T1, typename _T2>
struct _PCC
{
template <typename _U1, typename _U2>
static constexpr bool _ConstructiblePair()
{
return __and_<is_constructible<_T1, const _U1&>,
is_constructible<_T2, const _U2&>>::value;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyConvertiblePair()
{
return __and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value;
}
template <typename _U1, typename _U2>
static constexpr bool _MoveConstructiblePair()
{
return __and_<is_constructible<_T1, _U1&&>,
is_constructible<_T2, _U2&&>>::value;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyMoveConvertiblePair()
{
return __and_<is_convertible<_U1&&, _T1>,
is_convertible<_U2&&, _T2>>::value;
}
template <bool __implicit, typename _U1, typename _U2>
static constexpr bool _CopyMovePair()
{
using __do_converts = __and_<is_convertible<const _U1&, _T1>,
is_convertible<_U2&&, _T2>>;
using __converts = typename conditional<__implicit,
__do_converts,
__not_<__do_converts>>::type;
return __and_<is_constructible<_T1, const _U1&>,
is_constructible<_T2, _U2&&>,
__converts
>::value;
}
template <bool __implicit, typename _U1, typename _U2>
static constexpr bool _MoveCopyPair()
{
using __do_converts = __and_<is_convertible<_U1&&, _T1>,
is_convertible<const _U2&, _T2>>;
using __converts = typename conditional<__implicit,
__do_converts,
__not_<__do_converts>>::type;
return __and_<is_constructible<_T1, _U1&&>,
is_constructible<_T2, const _U2&&>,
__converts
>::value;
}
};
template <typename _T1, typename _T2>
struct _PCC<false, _T1, _T2>
{
template <typename _U1, typename _U2>
static constexpr bool _ConstructiblePair()
{
return false;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyConvertiblePair()
{
return false;
}
template <typename _U1, typename _U2>
static constexpr bool _MoveConstructiblePair()
{
return false;
}
template <typename _U1, typename _U2>
static constexpr bool _ImplicitlyMoveConvertiblePair()
{
return false;
}
};
template<typename _U1, typename _U2> class __pair_base
{
template<typename _T1, typename _T2> friend struct pair;
__pair_base() = default;
~__pair_base() = default;
__pair_base(const __pair_base&) = default;
__pair_base& operator=(const __pair_base&) = delete;
};
# 210 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
struct pair
: private __pair_base<_T1, _T2>
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>
::value, bool>::type = true>
constexpr pair()
: first(), second() { }
template <typename _U1 = _T1,
typename _U2 = _T2,
typename enable_if<__and_<
is_default_constructible<_U1>,
is_default_constructible<_U2>,
__not_<
__and_<__is_implicitly_default_constructible<_U1>,
__is_implicitly_default_constructible<_U2>>>>
::value, bool>::type = false>
explicit constexpr pair()
: first(), second() { }
# 256 "/usr/include/c++/10/bits/stl_pair.h" 3
using _PCCP = _PCC<true, _T1, _T2>;
template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_PCCP::template
_ConstructiblePair<_U1, _U2>()
&& _PCCP::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_PCCP::template
_ConstructiblePair<_U1, _U2>()
&& !_PCCP::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
# 288 "/usr/include/c++/10/bits/stl_pair.h" 3
template <typename _U1, typename _U2>
using _PCCFP = _PCC<!is_same<_T1, _U1>::value
|| !is_same<_T2, _U2>::value,
_T1, _T2>;
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_ConstructiblePair<_U1, _U2>()
&& _PCCFP<_U1, _U2>::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_ConstructiblePair<_U1, _U2>()
&& !_PCCFP<_U1, _U2>::template
_ImplicitlyConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
template<typename _U1, typename
enable_if<_PCCP::template
_MoveCopyPair<true, _U1, _T2>(),
bool>::type=true>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<typename _U1, typename
enable_if<_PCCP::template
_MoveCopyPair<false, _U1, _T2>(),
bool>::type=false>
explicit constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<typename _U2, typename
enable_if<_PCCP::template
_CopyMovePair<true, _T1, _U2>(),
bool>::type=true>
constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<typename _U2, typename
enable_if<_PCCP::template
_CopyMovePair<false, _T1, _U2>(),
bool>::type=false>
explicit pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCP::template
_MoveConstructiblePair<_U1, _U2>()
&& _PCCP::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCP::template
_MoveConstructiblePair<_U1, _U2>()
&& !_PCCP::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_MoveConstructiblePair<_U1, _U2>()
&& _PCCFP<_U1, _U2>::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=true>
constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
template<typename _U1, typename _U2, typename
enable_if<_PCCFP<_U1, _U2>::template
_MoveConstructiblePair<_U1, _U2>()
&& !_PCCFP<_U1, _U2>::template
_ImplicitlyMoveConvertiblePair<_U1, _U2>(),
bool>::type=false>
explicit constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
template<typename... _Args1, typename... _Args2>
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
pair&
operator=(typename conditional<
__and_<is_copy_assignable<_T1>,
is_copy_assignable<_T2>>::value,
const pair&, const __nonesuch&>::type __p)
{
first = __p.first;
second = __p.second;
return *this;
}
pair&
operator=(typename conditional<
__and_<is_move_assignable<_T1>,
is_move_assignable<_T2>>::value,
pair&&, __nonesuch&&>::type __p)
noexcept(__and_<is_nothrow_move_assignable<_T1>,
is_nothrow_move_assignable<_T2>>::value)
{
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}
template<typename _U1, typename _U2>
typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
is_assignable<_T2&, const _U2&>>::value,
pair&>::type
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
template<typename _U1, typename _U2>
typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
is_assignable<_T2&, _U2&&>>::value,
pair&>::type
operator=(pair<_U1, _U2>&& __p)
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void
swap(pair& __p)
noexcept(__and_<__is_nothrow_swappable<_T1>,
__is_nothrow_swappable<_T2>>::value)
{
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
template<typename... _Args1, std::size_t... _Indexes1,
typename... _Args2, std::size_t... _Indexes2>
pair(tuple<_Args1...>&, tuple<_Args2...>&,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
};
# 464 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
inline constexpr bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
# 487 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
inline constexpr bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
template<typename _T1, typename _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<typename _T1, typename _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<typename _T1, typename _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<typename _T1, typename _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
# 524 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
inline
typename enable_if<__and_<__is_swappable<_T1>,
__is_swappable<_T2>>::value>::type
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename _T1, typename _T2>
typename enable_if<!__and_<__is_swappable<_T1>,
__is_swappable<_T2>>::value>::type
swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
# 564 "/usr/include/c++/10/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
constexpr pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type>
make_pair(_T1&& __x, _T2&& __y)
{
typedef typename __decay_and_strip<_T1>::__type __ds_type1;
typedef typename __decay_and_strip<_T2>::__type __ds_type2;
typedef pair<__ds_type1, __ds_type2> __pair_type;
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
# 583 "/usr/include/c++/10/bits/stl_pair.h" 3
}
# 71 "/usr/include/c++/10/utility" 2 3
# 1 "/usr/include/c++/10/initializer_list" 1 3
# 33 "/usr/include/c++/10/initializer_list" 3
# 34 "/usr/include/c++/10/initializer_list" 3
#pragma GCC visibility push(default)
namespace std
{
template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
constexpr size_type
size() const noexcept { return _M_len; }
constexpr const_iterator
begin() const noexcept { return _M_array; }
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma GCC visibility pop
# 77 "/usr/include/c++/10/utility" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
struct tuple_size;
template<typename _Tp,
typename _Up = typename remove_cv<_Tp>::type,
typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
size_t = tuple_size<_Tp>::value>
using __enable_if_has_tuple_size = _Tp;
template<typename _Tp>
struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };
template<typename _Tp>
struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };
template<typename _Tp>
struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };
template<std::size_t __i, typename _Tp>
struct tuple_element;
template<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp>
{
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
{ };
template<class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2>>
: public integral_constant<std::size_t, 2> { };
template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; };
template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2>>
{ typedef _Tp2 type; };
template<std::size_t _Int>
struct __pair_get;
template<>
struct __pair_get<0>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp1>(__pair.first); }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp1&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp1&&
__const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<const _Tp1>(__pair.first); }
};
template<>
struct __pair_get<1>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&&
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp2>(__pair.second); }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp2&
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }
template<typename _Tp1, typename _Tp2>
static constexpr const _Tp2&&
__const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<const _Tp2>(__pair.second); }
};
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
get(std::pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__get(__in); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
get(std::pair<_Tp1, _Tp2>&& __in) noexcept
{ return __pair_get<_Int>::__move_get(std::move(__in)); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
get(const std::pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__const_get(__in); }
template<std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
{ return __pair_get<_Int>::__const_move_get(std::move(__in)); }
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }
template <typename _Tp, typename _Up>
constexpr const _Tp&&
get(const pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr _Tp&&
get(pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
template <typename _Tp, typename _Up>
constexpr const _Tp&&
get(const pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
template <typename _Tp, typename _Up = _Tp>
inline _Tp
exchange(_Tp& __obj, _Up&& __new_val)
{ return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
template<size_t... _Indexes> struct _Index_tuple { };
# 307 "/usr/include/c++/10/utility" 3
template<size_t _Num>
struct _Build_index_tuple
{
using __type = _Index_tuple<__integer_pack(_Num)...>;
};
template<typename _Tp, _Tp... _Idx>
struct integer_sequence
{
typedef _Tp value_type;
static constexpr size_t size() noexcept { return sizeof...(_Idx); }
};
template<typename _Tp, _Tp _Num>
using make_integer_sequence
= integer_sequence<_Tp, __integer_pack(_Num)...>;
template<size_t... _Idx>
using index_sequence = integer_sequence<size_t, _Idx...>;
template<size_t _Num>
using make_index_sequence = make_integer_sequence<size_t, _Num>;
template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
# 473 "/usr/include/c++/10/utility" 3
}
# 238 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 259 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 36 "/usr/include/c++/10/stdlib.h" 3
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
# 40 "/usr/include/c++/10/cstdlib" 3
# 75 "/usr/include/c++/10/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 26 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 32 "/usr/include/stdlib.h" 2 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 40 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 55 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
# 75 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
# 87 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
typedef __float128 _Float128;
# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef float _Float32;
# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float64;
# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef double _Float32x;
# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
typedef long double _Float64x;
# 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
# 56 "/usr/include/stdlib.h" 2 3 4
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
# 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
# 140 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float64 strtof64 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float128 strtof128 (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float32x strtof32x (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern _Float64x strtof64x (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
# 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern int strfromd (char *__dest, size_t __size, const char *__format,
double __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf (char *__dest, size_t __size, const char *__format,
float __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfroml (char *__dest, size_t __size, const char *__format,
long double __f)
throw () __attribute__ ((__nonnull__ (3)));
# 232 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
_Float32 __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf64 (char *__dest, size_t __size, const char * __format,
_Float64 __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf128 (char *__dest, size_t __size, const char * __format,
_Float128 __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf32x (char *__dest, size_t __size, const char * __format,
_Float32x __f)
throw () __attribute__ ((__nonnull__ (3)));
extern int strfromf64x (char *__dest, size_t __size, const char * __format,
_Float64x __f)
throw () __attribute__ ((__nonnull__ (3)));
# 274 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
# 316 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float64 strtof64_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float128 strtof128_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float32x strtof32x_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern _Float64x strtof64x_l (const char *__restrict __nptr,
char **__restrict __endptr,
locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
# 360 "/usr/include/stdlib.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
{
return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
{
return strtol (__nptr, (char **) __null, 10);
}
__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
{
return strtoll (__nptr, (char **) __null, 10);
}
# 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () ;
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
# 401 "/usr/include/stdlib.h" 3 4
extern long int random (void) throw ();
extern void srandom (unsigned int __seed) throw ();
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) throw ();
extern void srand (unsigned int __seed) throw ();
extern int rand_r (unsigned int *__seed) throw ();
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
throw () __attribute__ ((__warn_unused_result__))
__attribute__ ((__alloc_size__ (2, 3)));
extern void free (void *__ptr) throw ();
# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4
extern "C" {
extern void *alloca (size_t __size) throw ();
}
# 569 "/usr/include/stdlib.h" 2 3 4
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__))
__attribute__ ((__alloc_size__ (1))) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
# 610 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) throw ();
# 675 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 688 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 698 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 710 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 720 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
# 731 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 742 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 752 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 762 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
# 774 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
# 784 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
# 800 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
typedef int (*__compar_fn_t) (const void *, const void *);
typedef __compar_fn_t comparison_fn_t;
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 1 3 4
# 19 "/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) void *
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar)
{
size_t __l, __u, __idx;
const void *__p;
int __comparison;
__l = 0;
__u = __nmemb;
while (__l < __u)
{
__idx = (__l + __u) / 2;
__p = (void *) (((const char *) __base) + (__idx * __size));
__comparison = (*__compar) (__key, __p);
if (__comparison < 0)
__u = __idx;
else if (__comparison > 0)
__l = __idx + 1;
else
return (void *) __p;
}
return __null;
}
# 826 "/usr/include/stdlib.h" 2 3 4
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
# 872 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) throw ();
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
extern int wctomb (char *__s, wchar_t __wchar) throw ();
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 957 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
extern int posix_openpt (int __oflag) ;
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () ;
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int getpt (void);
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
# 1013 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) double
__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
{
return strtod (__nptr, (char **) __null);
}
# 1014 "/usr/include/stdlib.h" 2 3 4
# 1023 "/usr/include/stdlib.h" 3 4
}
# 76 "/usr/include/c++/10/cstdlib" 2 3
# 1 "/usr/include/c++/10/bits/std_abs.h" 1 3
# 33 "/usr/include/c++/10/bits/std_abs.h" 3
# 34 "/usr/include/c++/10/bits/std_abs.h" 3
# 46 "/usr/include/c++/10/bits/std_abs.h" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::abs;
inline long
abs(long __i) { return __builtin_labs(__i); }
inline long long
abs(long long __x) { return __builtin_llabs (__x); }
# 70 "/usr/include/c++/10/bits/std_abs.h" 3
inline constexpr double
abs(double __x)
{ return __builtin_fabs(__x); }
inline constexpr float
abs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
abs(long double __x)
{ return __builtin_fabsl(__x); }
inline constexpr __int128
abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 101 "/usr/include/c++/10/bits/std_abs.h" 3
inline constexpr
__float128
abs(__float128 __x)
{ return __x < 0 ? -__x : __x; }
}
}
# 78 "/usr/include/c++/10/cstdlib" 2 3
# 121 "/usr/include/c++/10/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::atexit;
using ::at_quick_exit;
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
using ::qsort;
using ::quick_exit;
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
using ::wcstombs;
using ::wctomb;
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
}
# 195 "/usr/include/c++/10/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using ::lldiv_t;
using ::_Exit;
using ::llabs;
inline lldiv_t
div(long long __n, long long __d)
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
using ::lldiv;
# 227 "/usr/include/c++/10/cstdlib" 3
using ::atoll;
using ::strtoll;
using ::strtoull;
using ::strtof;
using ::strtold;
}
namespace std
{
using ::__gnu_cxx::lldiv_t;
using ::__gnu_cxx::_Exit;
using ::__gnu_cxx::llabs;
using ::__gnu_cxx::div;
using ::__gnu_cxx::lldiv;
using ::__gnu_cxx::atoll;
using ::__gnu_cxx::strtof;
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
}
}
# 37 "/usr/include/c++/10/stdlib.h" 2 3
using std::abort;
using std::atexit;
using std::exit;
using std::at_quick_exit;
using std::quick_exit;
using std::div_t;
using std::ldiv_t;
using std::abs;
using std::atof;
using std::atoi;
using std::atol;
using std::bsearch;
using std::calloc;
using std::div;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::malloc;
using std::mblen;
using std::mbstowcs;
using std::mbtowc;
using std::qsort;
using std::rand;
using std::realloc;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;
using std::wcstombs;
using std::wctomb;
# 260 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
# 40 "/usr/include/c++/10/cstdlib" 3
# 268 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 295 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/unistd.h" 1 3 4
# 27 "/usr/include/unistd.h" 3 4
extern "C" {
# 202 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix_opt.h" 1 3 4
# 203 "/usr/include/unistd.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/environments.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/environments.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/environments.h" 2 3 4
# 207 "/usr/include/unistd.h" 2 3 4
# 226 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 227 "/usr/include/unistd.h" 2 3 4
# 267 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;
typedef __socklen_t socklen_t;
# 287 "/usr/include/unistd.h" 3 4
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
# 334 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 345 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
extern int close (int __fd);
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
# 376 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) ;
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) ;
# 404 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) ;
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) ;
extern int pipe (int __pipedes[2]) throw () ;
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
# 432 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 444 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
# 469 "/usr/include/unistd.h" 3 4
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchdir (int __fd) throw () ;
# 511 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () ;
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
extern int dup (int __fd) throw () ;
extern int dup2 (int __fd, int __fd2) throw ();
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
extern char **__environ;
extern char **environ;
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nice (int __inc) throw () ;
extern void _exit (int __status) __attribute__ ((__noreturn__));
# 1 "/usr/include/x86_64-linux-gnu/bits/confname.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/confname.h" 3 4
enum
{
_PC_LINK_MAX,
_PC_MAX_CANON,
_PC_MAX_INPUT,
_PC_NAME_MAX,
_PC_PATH_MAX,
_PC_PIPE_BUF,
_PC_CHOWN_RESTRICTED,
_PC_NO_TRUNC,
_PC_VDISABLE,
_PC_SYNC_IO,
_PC_ASYNC_IO,
_PC_PRIO_IO,
_PC_SOCK_MAXBUF,
_PC_FILESIZEBITS,
_PC_REC_INCR_XFER_SIZE,
_PC_REC_MAX_XFER_SIZE,
_PC_REC_MIN_XFER_SIZE,
_PC_REC_XFER_ALIGN,
_PC_ALLOC_SIZE_MIN,
_PC_SYMLINK_MAX,
_PC_2_SYMLINKS
};
enum
{
_SC_ARG_MAX,
_SC_CHILD_MAX,
_SC_CLK_TCK,
_SC_NGROUPS_MAX,
_SC_OPEN_MAX,
_SC_STREAM_MAX,
_SC_TZNAME_MAX,
_SC_JOB_CONTROL,
_SC_SAVED_IDS,
_SC_REALTIME_SIGNALS,
_SC_PRIORITY_SCHEDULING,
_SC_TIMERS,
_SC_ASYNCHRONOUS_IO,
_SC_PRIORITIZED_IO,
_SC_SYNCHRONIZED_IO,
_SC_FSYNC,
_SC_MAPPED_FILES,
_SC_MEMLOCK,
_SC_MEMLOCK_RANGE,
_SC_MEMORY_PROTECTION,
_SC_MESSAGE_PASSING,
_SC_SEMAPHORES,
_SC_SHARED_MEMORY_OBJECTS,
_SC_AIO_LISTIO_MAX,
_SC_AIO_MAX,
_SC_AIO_PRIO_DELTA_MAX,
_SC_DELAYTIMER_MAX,
_SC_MQ_OPEN_MAX,
_SC_MQ_PRIO_MAX,
_SC_VERSION,
_SC_PAGESIZE,
_SC_RTSIG_MAX,
_SC_SEM_NSEMS_MAX,
_SC_SEM_VALUE_MAX,
_SC_SIGQUEUE_MAX,
_SC_TIMER_MAX,
_SC_BC_BASE_MAX,
_SC_BC_DIM_MAX,
_SC_BC_SCALE_MAX,
_SC_BC_STRING_MAX,
_SC_COLL_WEIGHTS_MAX,
_SC_EQUIV_CLASS_MAX,
_SC_EXPR_NEST_MAX,
_SC_LINE_MAX,
_SC_RE_DUP_MAX,
_SC_CHARCLASS_NAME_MAX,
_SC_2_VERSION,
_SC_2_C_BIND,
_SC_2_C_DEV,
_SC_2_FORT_DEV,
_SC_2_FORT_RUN,
_SC_2_SW_DEV,
_SC_2_LOCALEDEF,
_SC_PII,
_SC_PII_XTI,
_SC_PII_SOCKET,
_SC_PII_INTERNET,
_SC_PII_OSI,
_SC_POLL,
_SC_SELECT,
_SC_UIO_MAXIOV,
_SC_IOV_MAX = _SC_UIO_MAXIOV,
_SC_PII_INTERNET_STREAM,
_SC_PII_INTERNET_DGRAM,
_SC_PII_OSI_COTS,
_SC_PII_OSI_CLTS,
_SC_PII_OSI_M,
_SC_T_IOV_MAX,
_SC_THREADS,
_SC_THREAD_SAFE_FUNCTIONS,
_SC_GETGR_R_SIZE_MAX,
_SC_GETPW_R_SIZE_MAX,
_SC_LOGIN_NAME_MAX,
_SC_TTY_NAME_MAX,
_SC_THREAD_DESTRUCTOR_ITERATIONS,
_SC_THREAD_KEYS_MAX,
_SC_THREAD_STACK_MIN,
_SC_THREAD_THREADS_MAX,
_SC_THREAD_ATTR_STACKADDR,
_SC_THREAD_ATTR_STACKSIZE,
_SC_THREAD_PRIORITY_SCHEDULING,
_SC_THREAD_PRIO_INHERIT,
_SC_THREAD_PRIO_PROTECT,
_SC_THREAD_PROCESS_SHARED,
_SC_NPROCESSORS_CONF,
_SC_NPROCESSORS_ONLN,
_SC_PHYS_PAGES,
_SC_AVPHYS_PAGES,
_SC_ATEXIT_MAX,
_SC_PASS_MAX,
_SC_XOPEN_VERSION,
_SC_XOPEN_XCU_VERSION,
_SC_XOPEN_UNIX,
_SC_XOPEN_CRYPT,
_SC_XOPEN_ENH_I18N,
_SC_XOPEN_SHM,
_SC_2_CHAR_TERM,
_SC_2_C_VERSION,
_SC_2_UPE,
_SC_XOPEN_XPG2,
_SC_XOPEN_XPG3,
_SC_XOPEN_XPG4,
_SC_CHAR_BIT,
_SC_CHAR_MAX,
_SC_CHAR_MIN,
_SC_INT_MAX,
_SC_INT_MIN,
_SC_LONG_BIT,
_SC_WORD_BIT,
_SC_MB_LEN_MAX,
_SC_NZERO,
_SC_SSIZE_MAX,
_SC_SCHAR_MAX,
_SC_SCHAR_MIN,
_SC_SHRT_MAX,
_SC_SHRT_MIN,
_SC_UCHAR_MAX,
_SC_UINT_MAX,
_SC_ULONG_MAX,
_SC_USHRT_MAX,
_SC_NL_ARGMAX,
_SC_NL_LANGMAX,
_SC_NL_MSGMAX,
_SC_NL_NMAX,
_SC_NL_SETMAX,
_SC_NL_TEXTMAX,
_SC_XBS5_ILP32_OFF32,
_SC_XBS5_ILP32_OFFBIG,
_SC_XBS5_LP64_OFF64,
_SC_XBS5_LPBIG_OFFBIG,
_SC_XOPEN_LEGACY,
_SC_XOPEN_REALTIME,
_SC_XOPEN_REALTIME_THREADS,
_SC_ADVISORY_INFO,
_SC_BARRIERS,
_SC_BASE,
_SC_C_LANG_SUPPORT,
_SC_C_LANG_SUPPORT_R,
_SC_CLOCK_SELECTION,
_SC_CPUTIME,
_SC_THREAD_CPUTIME,
_SC_DEVICE_IO,
_SC_DEVICE_SPECIFIC,
_SC_DEVICE_SPECIFIC_R,
_SC_FD_MGMT,
_SC_FIFO,
_SC_PIPE,
_SC_FILE_ATTRIBUTES,
_SC_FILE_LOCKING,
_SC_FILE_SYSTEM,
_SC_MONOTONIC_CLOCK,
_SC_MULTI_PROCESS,
_SC_SINGLE_PROCESS,
_SC_NETWORKING,
_SC_READER_WRITER_LOCKS,
_SC_SPIN_LOCKS,
_SC_REGEXP,
_SC_REGEX_VERSION,
_SC_SHELL,
_SC_SIGNALS,
_SC_SPAWN,
_SC_SPORADIC_SERVER,
_SC_THREAD_SPORADIC_SERVER,
_SC_SYSTEM_DATABASE,
_SC_SYSTEM_DATABASE_R,
_SC_TIMEOUTS,
_SC_TYPED_MEMORY_OBJECTS,
_SC_USER_GROUPS,
_SC_USER_GROUPS_R,
_SC_2_PBS,
_SC_2_PBS_ACCOUNTING,
_SC_2_PBS_LOCATE,
_SC_2_PBS_MESSAGE,
_SC_2_PBS_TRACK,
_SC_SYMLOOP_MAX,
_SC_STREAMS,
_SC_2_PBS_CHECKPOINT,
_SC_V6_ILP32_OFF32,
_SC_V6_ILP32_OFFBIG,
_SC_V6_LP64_OFF64,
_SC_V6_LPBIG_OFFBIG,
_SC_HOST_NAME_MAX,
_SC_TRACE,
_SC_TRACE_EVENT_FILTER,
_SC_TRACE_INHERIT,
_SC_TRACE_LOG,
_SC_LEVEL1_ICACHE_SIZE,
_SC_LEVEL1_ICACHE_ASSOC,
_SC_LEVEL1_ICACHE_LINESIZE,
_SC_LEVEL1_DCACHE_SIZE,
_SC_LEVEL1_DCACHE_ASSOC,
_SC_LEVEL1_DCACHE_LINESIZE,
_SC_LEVEL2_CACHE_SIZE,
_SC_LEVEL2_CACHE_ASSOC,
_SC_LEVEL2_CACHE_LINESIZE,
_SC_LEVEL3_CACHE_SIZE,
_SC_LEVEL3_CACHE_ASSOC,
_SC_LEVEL3_CACHE_LINESIZE,
_SC_LEVEL4_CACHE_SIZE,
_SC_LEVEL4_CACHE_ASSOC,
_SC_LEVEL4_CACHE_LINESIZE,
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
_SC_RAW_SOCKETS,
_SC_V7_ILP32_OFF32,
_SC_V7_ILP32_OFFBIG,
_SC_V7_LP64_OFF64,
_SC_V7_LPBIG_OFFBIG,
_SC_SS_REPL_MAX,
_SC_TRACE_EVENT_NAME_MAX,
_SC_TRACE_NAME_MAX,
_SC_TRACE_SYS_MAX,
_SC_TRACE_USER_EVENT_MAX,
_SC_XOPEN_STREAMS,
_SC_THREAD_ROBUST_PRIO_INHERIT,
_SC_THREAD_ROBUST_PRIO_PROTECT
};
enum
{
_CS_PATH,
_CS_V6_WIDTH_RESTRICTED_ENVS,
_CS_GNU_LIBC_VERSION,
_CS_GNU_LIBPTHREAD_VERSION,
_CS_V5_WIDTH_RESTRICTED_ENVS,
_CS_V7_WIDTH_RESTRICTED_ENVS,
_CS_LFS_CFLAGS = 1000,
_CS_LFS_LDFLAGS,
_CS_LFS_LIBS,
_CS_LFS_LINTFLAGS,
_CS_LFS64_CFLAGS,
_CS_LFS64_LDFLAGS,
_CS_LFS64_LIBS,
_CS_LFS64_LINTFLAGS,
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
_CS_XBS5_ILP32_OFF32_LDFLAGS,
_CS_XBS5_ILP32_OFF32_LIBS,
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
_CS_XBS5_ILP32_OFFBIG_LIBS,
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
_CS_XBS5_LP64_OFF64_CFLAGS,
_CS_XBS5_LP64_OFF64_LDFLAGS,
_CS_XBS5_LP64_OFF64_LIBS,
_CS_XBS5_LP64_OFF64_LINTFLAGS,
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
_CS_XBS5_LPBIG_OFFBIG_LIBS,
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
_CS_POSIX_V6_ILP32_OFF32_LIBS,
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
_CS_POSIX_V6_LP64_OFF64_LIBS,
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
_CS_POSIX_V7_ILP32_OFF32_LIBS,
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
_CS_POSIX_V7_LP64_OFF64_LIBS,
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
_CS_V6_ENV,
_CS_V7_ENV
};
# 610 "/usr/include/unistd.h" 2 3 4
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
extern long int fpathconf (int __fd, int __name) throw ();
extern long int sysconf (int __name) throw ();
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
extern __pid_t getpid (void) throw ();
extern __pid_t getppid (void) throw ();
extern __pid_t getpgrp (void) throw ();
extern __pid_t __getpgid (__pid_t __pid) throw ();
extern __pid_t getpgid (__pid_t __pid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
# 660 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
extern __pid_t setsid (void) throw ();
extern __pid_t getsid (__pid_t __pid) throw ();
extern __uid_t getuid (void) throw ();
extern __uid_t geteuid (void) throw ();
extern __gid_t getgid (void) throw ();
extern __gid_t getegid (void) throw ();
extern int getgroups (int __size, __gid_t __list[]) throw () ;
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () ;
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
extern int seteuid (__uid_t __uid) throw () ;
extern int setgid (__gid_t __gid) throw () ;
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
extern int setegid (__gid_t __gid) throw () ;
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () ;
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () ;
extern __pid_t fork (void) throw ();
extern __pid_t vfork (void) throw ();
extern char *ttyname (int __fd) throw ();
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int isatty (int __fd) throw ();
extern int ttyslot (void) throw ();
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) ;
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) ;
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
extern __pid_t tcgetpgrp (int __fd) throw ();
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
extern char *getlogin (void);
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
# 1 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
extern "C" {
extern char *optarg;
# 50 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
extern int optind;
extern int opterr;
extern int optopt;
# 91 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw () __attribute__ ((__nonnull__ (2, 3)));
}
# 28 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 2 3 4
extern "C" {
# 49 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
}
# 870 "/usr/include/unistd.h" 2 3 4
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int sethostid (long int __id) throw () ;
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
extern int acct (const char *__name) throw ();
extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();
extern int daemon (int __nochdir, int __noclose) throw () ;
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
extern int fsync (int __fd);
extern int syncfs (int __fd) throw ();
extern long int gethostid (void);
extern void sync (void) throw ();
extern int getpagesize (void) throw () __attribute__ ((__const__));
extern int getdtablesize (void) throw ();
# 991 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
# 1003 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
# 1014 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () ;
# 1024 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
# 1035 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () ;
extern void *sbrk (intptr_t __delta) throw ();
# 1056 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1079 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1089 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1107 "/usr/include/unistd.h" 3 4
ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
int __outfd, __off64_t *__poutoff,
size_t __length, unsigned int __flags);
extern int fdatasync (int __fildes);
# 1124 "/usr/include/unistd.h" 3 4
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
# 1161 "/usr/include/unistd.h" 3 4
int getentropy (void *__buffer, size_t __length) ;
# 1170 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/unistd_ext.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/unistd_ext.h" 3 4
extern __pid_t gettid (void) throw ();
# 1171 "/usr/include/unistd.h" 2 3 4
}
# 296 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/sys/param.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/sys/param.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/syslimits.h" 1 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 195 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 26 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/limits.h" 2 3 4
# 183 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4
# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 184 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4
# 188 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4
# 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4
# 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
# 192 "/usr/include/limits.h" 2 3 4
# 196 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-linux-gnu/10/include/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 2 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 1 "/usr/include/signal.h" 1 3 4
# 27 "/usr/include/signal.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/signum.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/signum.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/signum-generic.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/signum.h" 2 3 4
# 31 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h" 1 3 4
typedef __sig_atomic_t sig_atomic_t;
# 33 "/usr/include/signal.h" 2 3 4
# 57 "/usr/include/signal.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 5 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h" 3 4
union sigval
{
int sival_int;
void *sival_ptr;
};
typedef union sigval __sigval_t;
# 7 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4
# 16 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-arch.h" 1 3 4
# 17 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 3 4
typedef struct
{
int si_signo;
int si_errno;
int si_code;
int __pad0;
union
{
int _pad[((128 / sizeof (int)) - 4)];
struct
{
__pid_t si_pid;
__uid_t si_uid;
} _kill;
struct
{
int si_tid;
int si_overrun;
__sigval_t si_sigval;
} _timer;
struct
{
__pid_t si_pid;
__uid_t si_uid;
__sigval_t si_sigval;
} _rt;
struct
{
__pid_t si_pid;
__uid_t si_uid;
int si_status;
__clock_t si_utime;
__clock_t si_stime;
} _sigchld;
struct
{
void *si_addr;
short int si_addr_lsb;
union
{
struct
{
void *_lower;
void *_upper;
} _addr_bnd;
__uint32_t _pkey;
} _bounds;
} _sigfault;
struct
{
long int si_band;
int si_fd;
} _sigpoll;
struct
{
void *_call_addr;
int _syscall;
unsigned int _arch;
} _sigsys;
} _sifields;
} siginfo_t ;
# 58 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 3 4
enum
{
SI_ASYNCNL = -60,
SI_DETHREAD = -7,
SI_TKILL,
SI_SIGIO,
SI_ASYNCIO,
SI_MESGQ,
SI_TIMER,
SI_QUEUE,
SI_USER,
SI_KERNEL = 0x80
# 66 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 3 4
};
enum
{
ILL_ILLOPC = 1,
ILL_ILLOPN,
ILL_ILLADR,
ILL_ILLTRP,
ILL_PRVOPC,
ILL_PRVREG,
ILL_COPROC,
ILL_BADSTK,
ILL_BADIADDR
};
enum
{
FPE_INTDIV = 1,
FPE_INTOVF,
FPE_FLTDIV,
FPE_FLTOVF,
FPE_FLTUND,
FPE_FLTRES,
FPE_FLTINV,
FPE_FLTSUB,
FPE_FLTUNK = 14,
FPE_CONDTRAP
};
enum
{
SEGV_MAPERR = 1,
SEGV_ACCERR,
SEGV_BNDERR,
SEGV_PKUERR,
SEGV_ACCADI,
SEGV_ADIDERR,
SEGV_ADIPERR
};
enum
{
BUS_ADRALN = 1,
BUS_ADRERR,
BUS_OBJERR,
BUS_MCEERR_AR,
BUS_MCEERR_AO
};
enum
{
TRAP_BRKPT = 1,
TRAP_TRACE,
TRAP_BRANCH,
TRAP_HWBKPT,
TRAP_UNK
};
enum
{
CLD_EXITED = 1,
CLD_KILLED,
CLD_DUMPED,
CLD_TRAPPED,
CLD_STOPPED,
CLD_CONTINUED
};
enum
{
POLL_IN = 1,
POLL_OUT,
POLL_MSG,
POLL_ERR,
POLL_PRI,
POLL_HUP
};
# 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h" 1 3 4
# 210 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 2 3 4
# 59 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h" 1 3 4
# 16 "/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h" 3 4
typedef __sigval_t sigval_t;
# 63 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 2 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 3 4
typedef struct sigevent
{
__sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union
{
int _pad[((64 / sizeof (int)) - 4)];
__pid_t _tid;
struct
{
void (*_function) (__sigval_t);
pthread_attr_t *_attribute;
} _sigev_thread;
} _sigev_un;
} sigevent_t;
# 67 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h" 3 4
enum
{
SIGEV_SIGNAL = 0,
SIGEV_NONE,
SIGEV_THREAD,
SIGEV_THREAD_ID = 4
};
# 68 "/usr/include/signal.h" 2 3 4
typedef void (*__sighandler_t) (int);
extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
throw ();
# 112 "/usr/include/signal.h" 3 4
extern int kill (__pid_t __pid, int __sig) throw ();
extern int killpg (__pid_t __pgrp, int __sig) throw ();
extern int raise (int __sig) throw ();
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
throw ();
extern int gsignal (int __sig) throw ();
extern void psignal (int __sig, const char *__s);
extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
# 151 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
# 170 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
# 185 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;
typedef __sighandler_t sig_t;
extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigismember (const sigset_t *__set, int __signo)
throw () __attribute__ ((__nonnull__ (1)));
extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigandset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int sigorset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
# 1 "/usr/include/x86_64-linux-gnu/bits/sigaction.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/sigaction.h" 3 4
struct sigaction
{
union
{
__sighandler_t sa_handler;
void (*sa_sigaction) (int, siginfo_t *, void *);
}
__sigaction_handler;
__sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
};
# 227 "/usr/include/signal.h" 2 3 4
extern int sigprocmask (int __how, const sigset_t *__restrict __set,
sigset_t *__restrict __oset) throw ();
extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
extern int sigaction (int __sig, const struct sigaction *__restrict __act,
struct sigaction *__restrict __oact) throw ();
extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
__attribute__ ((__nonnull__ (1, 2)));
extern int sigwaitinfo (const sigset_t *__restrict __set,
siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
extern int sigtimedwait (const sigset_t *__restrict __set,
siginfo_t *__restrict __info,
const struct timespec *__restrict __timeout)
__attribute__ ((__nonnull__ (1)));
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
throw ();
# 286 "/usr/include/signal.h" 3 4
extern const char *const _sys_siglist[(64 + 1)];
extern const char *const sys_siglist[(64 + 1)];
# 1 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 3 4
struct _fpx_sw_bytes
{
__uint32_t magic1;
__uint32_t extended_size;
__uint64_t xstate_bv;
__uint32_t xstate_size;
__uint32_t __glibc_reserved1[7];
};
struct _fpreg
{
unsigned short significand[4];
unsigned short exponent;
};
struct _fpxreg
{
unsigned short significand[4];
unsigned short exponent;
unsigned short __glibc_reserved1[3];
};
struct _xmmreg
{
__uint32_t element[4];
};
# 123 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 3 4
struct _fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _fpxreg _st[8];
struct _xmmreg _xmm[16];
__uint32_t __glibc_reserved1[24];
};
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
struct _xsave_hdr
{
__uint64_t xstate_bv;
__uint64_t __glibc_reserved1[2];
__uint64_t __glibc_reserved2[5];
};
struct _ymmh_state
{
__uint32_t ymmh_space[64];
};
struct _xstate
{
struct _fpstate fpstate;
struct _xsave_hdr xstate_hdr;
struct _ymmh_state ymmh;
};
# 292 "/usr/include/signal.h" 2 3 4
extern int sigreturn (struct sigcontext *__scp) throw ();
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 302 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 2 3 4
typedef struct
{
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
# 304 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 1 3 4
# 37 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 3 4
__extension__ typedef long long int greg_t;
# 46 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 3 4
typedef greg_t gregset_t[23];
enum
{
REG_R8 = 0,
REG_R9,
REG_R10,
REG_R11,
REG_R12,
REG_R13,
REG_R14,
REG_R15,
REG_RDI,
REG_RSI,
REG_RBP,
REG_RBX,
REG_RDX,
REG_RAX,
REG_RCX,
REG_RSP,
REG_RIP,
REG_EFL,
REG_CSGSFS,
REG_ERR,
REG_TRAPNO,
REG_OLDMASK,
REG_CR2
};
struct _libc_fpxreg
{
unsigned short int significand[4];
unsigned short int exponent;
unsigned short int __glibc_reserved1[3];
};
struct _libc_xmmreg
{
__uint32_t element[4];
};
struct _libc_fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _libc_fpxreg _st[8];
struct _libc_xmmreg _xmm[16];
__uint32_t __glibc_reserved1[24];
};
typedef struct _libc_fpstate *fpregset_t;
typedef struct
{
gregset_t gregs;
fpregset_t fpregs;
__extension__ unsigned long long __reserved1 [8];
} mcontext_t;
typedef struct ucontext_t
{
unsigned long int uc_flags;
struct ucontext_t *uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext;
sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
__extension__ unsigned long long int __ssp[4];
} ucontext_t;
# 307 "/usr/include/signal.h" 2 3 4
extern int siginterrupt (int __sig, int __interrupt) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/sigstack.h" 1 3 4
# 317 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/ss_flags.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/ss_flags.h" 3 4
enum
{
SS_ONSTACK = 1,
SS_DISABLE
};
# 318 "/usr/include/signal.h" 2 3 4
extern int sigaltstack (const stack_t *__restrict __ss,
stack_t *__restrict __oss) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h" 3 4
struct sigstack
{
void *ss_sp;
int ss_onstack;
};
# 328 "/usr/include/signal.h" 2 3 4
extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
throw () __attribute__ ((__deprecated__));
extern int sighold (int __sig) throw ();
extern int sigrelse (int __sig) throw ();
extern int sigignore (int __sig) throw ();
extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/sigthread.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how,
const __sigset_t *__restrict __newmask,
__sigset_t *__restrict __oldmask)throw ();
extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
extern int pthread_sigqueue (pthread_t __threadid, int __signo,
const union sigval __value) throw ();
# 360 "/usr/include/signal.h" 2 3 4
extern int __libc_current_sigrtmin (void) throw ();
extern int __libc_current_sigrtmax (void) throw ();
# 1 "/usr/include/x86_64-linux-gnu/bits/signal_ext.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/signal_ext.h" 3 4
extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal);
# 375 "/usr/include/signal.h" 2 3 4
}
# 29 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/param.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/param.h" 3 4
# 1 "/usr/include/linux/param.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/param.h" 1 3 4
# 1 "/usr/include/asm-generic/param.h" 1 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/param.h" 2 3 4
# 6 "/usr/include/linux/param.h" 2 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/param.h" 2 3 4
# 32 "/usr/include/x86_64-linux-gnu/sys/param.h" 2 3 4
# 300 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 307 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 337 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/time.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
extern "C" {
# 52 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
struct timezone
{
int tz_minuteswest;
int tz_dsttime;
};
# 66 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
void *__restrict __tz) throw () __attribute__ ((__nonnull__ (1)));
extern int settimeofday (const struct timeval *__tv,
const struct timezone *__tz)
throw ();
extern int adjtime (const struct timeval *__delta,
struct timeval *__olddelta) throw ();
enum __itimer_which
{
ITIMER_REAL = 0,
ITIMER_VIRTUAL = 1,
ITIMER_PROF = 2
};
struct itimerval
{
struct timeval it_interval;
struct timeval it_value;
};
typedef int __itimer_which_t;
extern int getitimer (__itimer_which_t __which,
struct itimerval *__value) throw ();
extern int setitimer (__itimer_which_t __which,
const struct itimerval *__restrict __new,
struct itimerval *__restrict __old) throw ();
extern int utimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int lutimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
extern int futimesat (int __fd, const char *__file,
const struct timeval __tvp[2]) throw ();
# 187 "/usr/include/x86_64-linux-gnu/sys/time.h" 3 4
}
# 338 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 30 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
# 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
# 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
# 34 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
# 40 "/usr/include/time.h" 2 3 4
# 48 "/usr/include/time.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
# 49 "/usr/include/time.h" 2 3 4
struct sigevent;
# 68 "/usr/include/time.h" 3 4
extern "C" {
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
# 190 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
# 205 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
# 274 "/usr/include/time.h" 3 4
extern int getdate_err;
# 283 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 297 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
# 339 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 350 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/fcntl.h" 1 3 4
# 28 "/usr/include/fcntl.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/fcntl.h" 1 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/fcntl.h" 3 4
struct flock
{
short int l_type;
short int l_whence;
__off_t l_start;
__off_t l_len;
__pid_t l_pid;
};
struct flock64
{
short int l_type;
short int l_whence;
__off64_t l_start;
__off64_t l_len;
__pid_t l_pid;
};
# 1 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/types/struct_iovec.h" 2 3 4
struct iovec
{
void *iov_base;
size_t iov_len;
};
# 39 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 2 3 4
# 265 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
enum __pid_type
{
F_OWNER_TID = 0,
F_OWNER_PID,
F_OWNER_PGRP,
F_OWNER_GID = F_OWNER_PGRP
};
struct f_owner_ex
{
enum __pid_type type;
__pid_t pid;
};
# 353 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/linux/falloc.h" 1 3 4
# 354 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 2 3 4
struct file_handle
{
unsigned int handle_bytes;
int handle_type;
unsigned char f_handle[0];
};
# 392 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
extern "C" {
extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
throw ();
extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
unsigned int __flags);
extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov,
size_t __count, unsigned int __flags);
extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
__off64_t *__offout, size_t __len,
unsigned int __flags);
extern __ssize_t tee (int __fdin, int __fdout, size_t __len,
unsigned int __flags);
extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
# 447 "/usr/include/x86_64-linux-gnu/bits/fcntl-linux.h" 3 4
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
__off64_t __len);
extern int name_to_handle_at (int __dfd, const char *__name,
struct file_handle *__handle, int *__mnt_id,
int __flags) throw ();
extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
int __flags);
}
# 62 "/usr/include/x86_64-linux-gnu/bits/fcntl.h" 2 3 4
# 36 "/usr/include/fcntl.h" 2 3 4
# 78 "/usr/include/fcntl.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stat.h" 1 3 4
# 46 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
struct stat
{
__dev_t st_dev;
__ino_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt_t st_blocks;
# 91 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
# 106 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
__syscall_slong_t __glibc_reserved[3];
# 115 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
};
struct stat64
{
__dev_t st_dev;
__ino64_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt64_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
# 164 "/usr/include/x86_64-linux-gnu/bits/stat.h" 3 4
__syscall_slong_t __glibc_reserved[3];
};
# 79 "/usr/include/fcntl.h" 2 3 4
# 148 "/usr/include/fcntl.h" 3 4
extern int fcntl (int __fd, int __cmd, ...);
# 157 "/usr/include/fcntl.h" 3 4
extern int fcntl64 (int __fd, int __cmd, ...);
# 168 "/usr/include/fcntl.h" 3 4
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 178 "/usr/include/fcntl.h" 3 4
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 192 "/usr/include/fcntl.h" 3 4
extern int openat (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
# 203 "/usr/include/fcntl.h" 3 4
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
# 214 "/usr/include/fcntl.h" 3 4
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 224 "/usr/include/fcntl.h" 3 4
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 260 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
int __advise) throw ();
# 272 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
int __advise) throw ();
# 282 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
# 293 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
# 304 "/usr/include/fcntl.h" 3 4
}
# 351 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 397 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/wait.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern "C" {
# 77 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern __pid_t wait (int *__stat_loc);
# 100 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
# 121 "/usr/include/x86_64-linux-gnu/sys/wait.h" 3 4
extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
int __options);
struct rusage;
extern __pid_t wait3 (int *__stat_loc, int __options,
struct rusage * __usage) throw ();
extern __pid_t wait4 (__pid_t __pid, int *__stat_loc, int __options,
struct rusage *__usage) throw ();
}
# 398 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 428 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/mman.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/sys/mman.h" 2 3 4
# 41 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/mman.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman-map-flags-generic.h" 1 3 4
# 32 "/usr/include/x86_64-linux-gnu/bits/mman.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman-linux.h" 1 3 4
# 113 "/usr/include/x86_64-linux-gnu/bits/mman-linux.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mman-shared.h" 1 3 4
# 46 "/usr/include/x86_64-linux-gnu/bits/mman-shared.h" 3 4
extern "C" {
int memfd_create (const char *__name, unsigned int __flags) throw ();
int mlock2 (const void *__addr, size_t __length, unsigned int __flags) throw ();
int pkey_alloc (unsigned int __flags, unsigned int __access_rights) throw ();
int pkey_set (int __key, unsigned int __access_rights) throw ();
int pkey_get (int __key) throw ();
int pkey_free (int __key) throw ();
int pkey_mprotect (void *__addr, size_t __len, int __prot, int __pkey) throw ();
}
# 114 "/usr/include/x86_64-linux-gnu/bits/mman-linux.h" 2 3 4
# 35 "/usr/include/x86_64-linux-gnu/bits/mman.h" 2 3 4
# 42 "/usr/include/x86_64-linux-gnu/sys/mman.h" 2 3 4
extern "C" {
# 57 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
extern void *mmap (void *__addr, size_t __len, int __prot,
int __flags, int __fd, __off_t __offset) throw ();
# 70 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
extern void *mmap64 (void *__addr, size_t __len, int __prot,
int __flags, int __fd, __off64_t __offset) throw ();
extern int munmap (void *__addr, size_t __len) throw ();
extern int mprotect (void *__addr, size_t __len, int __prot) throw ();
extern int msync (void *__addr, size_t __len, int __flags);
extern int madvise (void *__addr, size_t __len, int __advice) throw ();
extern int posix_madvise (void *__addr, size_t __len, int __advice) throw ();
extern int mlock (const void *__addr, size_t __len) throw ();
extern int munlock (const void *__addr, size_t __len) throw ();
extern int mlockall (int __flags) throw ();
extern int munlockall (void) throw ();
extern int mincore (void *__start, size_t __len, unsigned char *__vec)
throw ();
# 133 "/usr/include/x86_64-linux-gnu/sys/mman.h" 3 4
extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
int __flags, ...) throw ();
extern int remap_file_pages (void *__start, size_t __size, int __prot,
size_t __pgoff, int __flags) throw ();
extern int shm_open (const char *__name, int __oflag, mode_t __mode);
extern int shm_unlink (const char *__name);
}
# 429 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 440 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/resource.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/resource.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/resource.h" 3 4
enum __rlimit_resource
{
RLIMIT_CPU = 0,
RLIMIT_FSIZE = 1,
RLIMIT_DATA = 2,
RLIMIT_STACK = 3,
RLIMIT_CORE = 4,
__RLIMIT_RSS = 5,
RLIMIT_NOFILE = 7,
__RLIMIT_OFILE = RLIMIT_NOFILE,
RLIMIT_AS = 9,
__RLIMIT_NPROC = 6,
__RLIMIT_MEMLOCK = 8,
__RLIMIT_LOCKS = 10,
__RLIMIT_SIGPENDING = 11,
__RLIMIT_MSGQUEUE = 12,
__RLIMIT_NICE = 13,
__RLIMIT_RTPRIO = 14,
__RLIMIT_RTTIME = 15,
__RLIMIT_NLIMITS = 16,
__RLIM_NLIMITS = __RLIMIT_NLIMITS
};
# 131 "/usr/include/x86_64-linux-gnu/bits/resource.h" 3 4
typedef __rlim_t rlim_t;
typedef __rlim64_t rlim64_t;
struct rlimit
{
rlim_t rlim_cur;
rlim_t rlim_max;
};
struct rlimit64
{
rlim64_t rlim_cur;
rlim64_t rlim_max;
};
enum __rusage_who
{
RUSAGE_SELF = 0,
RUSAGE_CHILDREN = -1
,
RUSAGE_THREAD = 1
};
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_rusage.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/types/struct_rusage.h" 3 4
struct rusage
{
struct timeval ru_utime;
struct timeval ru_stime;
__extension__ union
{
long int ru_maxrss;
__syscall_slong_t __ru_maxrss_word;
};
__extension__ union
{
long int ru_ixrss;
__syscall_slong_t __ru_ixrss_word;
};
__extension__ union
{
long int ru_idrss;
__syscall_slong_t __ru_idrss_word;
};
__extension__ union
{
long int ru_isrss;
__syscall_slong_t __ru_isrss_word;
};
__extension__ union
{
long int ru_minflt;
__syscall_slong_t __ru_minflt_word;
};
__extension__ union
{
long int ru_majflt;
__syscall_slong_t __ru_majflt_word;
};
__extension__ union
{
long int ru_nswap;
__syscall_slong_t __ru_nswap_word;
};
__extension__ union
{
long int ru_inblock;
__syscall_slong_t __ru_inblock_word;
};
__extension__ union
{
long int ru_oublock;
__syscall_slong_t __ru_oublock_word;
};
__extension__ union
{
long int ru_msgsnd;
__syscall_slong_t __ru_msgsnd_word;
};
__extension__ union
{
long int ru_msgrcv;
__syscall_slong_t __ru_msgrcv_word;
};
__extension__ union
{
long int ru_nsignals;
__syscall_slong_t __ru_nsignals_word;
};
__extension__ union
{
long int ru_nvcsw;
__syscall_slong_t __ru_nvcsw_word;
};
__extension__ union
{
long int ru_nivcsw;
__syscall_slong_t __ru_nivcsw_word;
};
};
# 180 "/usr/include/x86_64-linux-gnu/bits/resource.h" 2 3 4
enum __priority_which
{
PRIO_PROCESS = 0,
PRIO_PGRP = 1,
PRIO_USER = 2
};
extern "C" {
extern int prlimit (__pid_t __pid, enum __rlimit_resource __resource,
const struct rlimit *__new_limit,
struct rlimit *__old_limit) throw ();
# 217 "/usr/include/x86_64-linux-gnu/bits/resource.h" 3 4
extern int prlimit64 (__pid_t __pid, enum __rlimit_resource __resource,
const struct rlimit64 *__new_limit,
struct rlimit64 *__old_limit) throw ();
}
# 25 "/usr/include/x86_64-linux-gnu/sys/resource.h" 2 3 4
extern "C" {
# 42 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
typedef int __rlimit_resource_t;
typedef int __rusage_who_t;
typedef int __priority_which_t;
extern int getrlimit (__rlimit_resource_t __resource,
struct rlimit *__rlimits) throw ();
# 61 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
extern int getrlimit64 (__rlimit_resource_t __resource,
struct rlimit64 *__rlimits) throw ();
extern int setrlimit (__rlimit_resource_t __resource,
const struct rlimit *__rlimits) throw ();
# 81 "/usr/include/x86_64-linux-gnu/sys/resource.h" 3 4
extern int setrlimit64 (__rlimit_resource_t __resource,
const struct rlimit64 *__rlimits) throw ();
extern int getrusage (__rusage_who_t __who, struct rusage *__usage) throw ();
extern int getpriority (__priority_which_t __which, id_t __who) throw ();
extern int setpriority (__priority_which_t __which, id_t __who, int __prio)
throw ();
}
# 441 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/sys/times.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/sys/times.h" 3 4
extern "C" {
struct tms
{
clock_t tms_utime;
clock_t tms_stime;
clock_t tms_cutime;
clock_t tms_cstime;
};
extern clock_t times (struct tms *__buffer) throw ();
}
# 445 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 453 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 453 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern "C" {
# 521 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
}
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
# 38 "/usr/include/stdint.h" 2 3 4
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;
typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 71 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 90 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 10 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 2 3 4
# 526 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/inttypes.h" 1 3 4
# 266 "/usr/include/inttypes.h" 3 4
extern "C" {
typedef struct
{
long int quot;
long int rem;
} imaxdiv_t;
# 290 "/usr/include/inttypes.h" 3 4
extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));
extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
throw () __attribute__ ((__const__));
extern intmax_t strtoimax (const char *__restrict __nptr,
char **__restrict __endptr, int __base) throw ();
extern uintmax_t strtoumax (const char *__restrict __nptr,
char ** __restrict __endptr, int __base) throw ();
extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
wchar_t ** __restrict __endptr, int __base)
throw ();
extern long int __strtol_internal (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()
{
return __strtol_internal (nptr, endptr, base, 0);
}
extern unsigned long int __strtoul_internal (const char *__restrict __nptr,
char ** __restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()
{
return __strtoul_internal (nptr, endptr, base, 0);
}
extern long int __wcstol_internal (const wchar_t * __restrict __nptr,
wchar_t **__restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) wcstoimax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()
{
return __wcstol_internal (nptr, endptr, base, 0);
}
extern unsigned long int __wcstoul_internal (const wchar_t *
__restrict __nptr,
wchar_t **
__restrict __endptr,
int __base, int __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) wcstoumax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()
{
return __wcstoul_internal (nptr, endptr, base, 0);
}
# 432 "/usr/include/inttypes.h" 3 4
}
# 530 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 533 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern "C" {
# 576 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
}
# 599 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/x86_64-linux-gnu/sys/stat.h" 1 3 4
# 99 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
# 99 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/stat.h" 1 3 4
# 102 "/usr/include/x86_64-linux-gnu/sys/stat.h" 2 3 4
# 205 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int stat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
# 224 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int stat64 (const char *__restrict __file,
struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int fstatat (int __fd, const char *__restrict __file,
struct stat *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
# 249 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int fstatat64 (int __fd, const char *__restrict __file,
struct stat64 *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int lstat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
# 272 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int lstat64 (const char *__restrict __file,
struct stat64 *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int chmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int lchmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int fchmod (int __fd, __mode_t __mode) throw ();
extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern __mode_t umask (__mode_t __mask) throw ();
extern __mode_t getumask (void) throw ();
extern int mkdir (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
throw () __attribute__ ((__nonnull__ (1)));
extern int mknodat (int __fd, const char *__path, __mode_t __mode,
__dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
extern int mkfifo (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int utimensat (int __fd, const char *__path,
const struct timespec __times[2],
int __flags)
throw () __attribute__ ((__nonnull__ (2)));
extern int futimens (int __fd, const struct timespec __times[2]) throw ();
# 395 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename,
struct stat *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
# 428 "/usr/include/x86_64-linux-gnu/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
struct stat64 *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
__dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
extern int __xmknodat (int __ver, int __fd, const char *__path,
__mode_t __mode, __dev_t *__dev)
throw () __attribute__ ((__nonnull__ (3, 5)));
# 1 "/usr/include/x86_64-linux-gnu/bits/statx.h" 1 3 4
# 31 "/usr/include/x86_64-linux-gnu/bits/statx.h" 3 4
# 1 "/usr/include/linux/stat.h" 1 3 4
# 1 "/usr/include/linux/types.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/types.h" 1 3 4
# 1 "/usr/include/asm-generic/types.h" 1 3 4
# 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
# 12 "/usr/include/asm-generic/int-ll64.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 3 4
# 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
# 12 "/usr/include/x86_64-linux-gnu/asm/bitsperlong.h" 2 3 4
# 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4
typedef __signed__ char __s8;
typedef unsigned char __u8;
typedef __signed__ short __s16;
typedef unsigned short __u16;
typedef __signed__ int __s32;
typedef unsigned int __u32;
__extension__ typedef __signed__ long long __s64;
__extension__ typedef unsigned long long __u64;
# 8 "/usr/include/asm-generic/types.h" 2 3 4
# 2 "/usr/include/x86_64-linux-gnu/asm/types.h" 2 3 4
# 6 "/usr/include/linux/types.h" 2 3 4
# 1 "/usr/include/linux/posix_types.h" 1 3 4
# 1 "/usr/include/linux/stddef.h" 1 3 4
# 6 "/usr/include/linux/posix_types.h" 2 3 4
# 25 "/usr/include/linux/posix_types.h" 3 4
typedef struct {
unsigned long fds_bits[1024 / (8 * sizeof(long))];
} __kernel_fd_set;
typedef void (*__kernel_sighandler_t)(int);
typedef int __kernel_key_t;
typedef int __kernel_mqd_t;
# 1 "/usr/include/x86_64-linux-gnu/asm/posix_types.h" 1 3 4
# 1 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 3 4
typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;
typedef unsigned long __kernel_old_dev_t;
# 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
# 15 "/usr/include/asm-generic/posix_types.h" 3 4
typedef long __kernel_long_t;
typedef unsigned long __kernel_ulong_t;
typedef __kernel_ulong_t __kernel_ino_t;
typedef unsigned int __kernel_mode_t;
typedef int __kernel_pid_t;
typedef int __kernel_ipc_pid_t;
typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;
typedef __kernel_long_t __kernel_suseconds_t;
typedef int __kernel_daddr_t;
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
# 72 "/usr/include/asm-generic/posix_types.h" 3 4
typedef __kernel_ulong_t __kernel_size_t;
typedef __kernel_long_t __kernel_ssize_t;
typedef __kernel_long_t __kernel_ptrdiff_t;
typedef struct {
int val[2];
} __kernel_fsid_t;
typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
typedef __kernel_long_t __kernel_old_time_t;
typedef __kernel_long_t __kernel_time_t;
typedef long long __kernel_time64_t;
typedef __kernel_long_t __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
# 19 "/usr/include/x86_64-linux-gnu/asm/posix_types_64.h" 2 3 4
# 8 "/usr/include/x86_64-linux-gnu/asm/posix_types.h" 2 3 4
# 37 "/usr/include/linux/posix_types.h" 2 3 4
# 10 "/usr/include/linux/types.h" 2 3 4
# 24 "/usr/include/linux/types.h" 3 4
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
typedef __u16 __sum16;
typedef __u32 __wsum;
# 47 "/usr/include/linux/types.h" 3 4
typedef unsigned __poll_t;
# 6 "/usr/include/linux/stat.h" 2 3 4
# 56 "/usr/include/linux/stat.h" 3 4
struct statx_timestamp {
__s64 tv_sec;
__u32 tv_nsec;
__s32 __reserved;
};
# 99 "/usr/include/linux/stat.h" 3 4
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 stx_attributes_mask;
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
# 32 "/usr/include/x86_64-linux-gnu/bits/statx.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_statx_timestamp.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_statx.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 2 3 4
# 53 "/usr/include/x86_64-linux-gnu/bits/statx-generic.h" 3 4
extern "C" {
int statx (int __dirfd, const char *__restrict __path, int __flags,
unsigned int __mask, struct statx *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 5)));
}
# 40 "/usr/include/x86_64-linux-gnu/bits/statx.h" 2 3 4
# 447 "/usr/include/x86_64-linux-gnu/sys/stat.h" 2 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) stat (const char *__path, struct stat *__statbuf) throw ()
{
return __xstat (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) lstat (const char *__path, struct stat *__statbuf) throw ()
{
return __lxstat (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstat (int __fd, struct stat *__statbuf) throw ()
{
return __fxstat (1, __fd, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag) throw ()
{
return __fxstatat (1, __fd, __filename, __statbuf, __flag);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev) throw ()
{
return __xmknod (0, __path, __mode, &__dev);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev) throw ()
{
return __xmknodat (0, __fd, __path, __mode, &__dev);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) stat64 (const char *__path, struct stat64 *__statbuf) throw ()
{
return __xstat64 (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf) throw ()
{
return __lxstat64 (1, __path, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstat64 (int __fd, struct stat64 *__statbuf) throw ()
{
return __fxstat64 (1, __fd, __statbuf);
}
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag) throw ()
{
return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
}
}
# 600 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 671 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h" 1
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h"
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h"
extern "C" {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/ansidecl.h" 1
# 40 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h" 2
typedef unsigned int hashval_t;
typedef hashval_t (*htab_hash) (const void *);
typedef int (*htab_eq) (const void *, const void *);
typedef void (*htab_del) (void *);
typedef int (*htab_trav) (void **, void *);
typedef void *(*htab_alloc) (size_t, size_t);
typedef void (*htab_free) (void *);
typedef void *(*htab_alloc_with_arg) (void *, size_t, size_t);
typedef void (*htab_free_with_arg) (void *, void *);
# 95 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h"
struct htab {
htab_hash hash_f;
htab_eq eq_f;
htab_del del_f;
void **entries;
size_t size;
size_t n_elements;
size_t n_deleted;
unsigned int searches;
unsigned int collisions;
htab_alloc alloc_f;
htab_free free_f;
void *alloc_arg;
htab_alloc_with_arg alloc_with_arg_f;
htab_free_with_arg free_with_arg_f;
unsigned int size_prime_index;
};
typedef struct htab *htab_t;
enum insert_option {NO_INSERT, INSERT};
extern htab_t htab_create_alloc (size_t, htab_hash,
htab_eq, htab_del,
htab_alloc, htab_free);
extern htab_t htab_create_alloc_ex (size_t, htab_hash,
htab_eq, htab_del,
void *, htab_alloc_with_arg,
htab_free_with_arg);
extern htab_t htab_create_typed_alloc (size_t, htab_hash, htab_eq, htab_del,
htab_alloc, htab_alloc, htab_free);
extern htab_t htab_create (size_t, htab_hash, htab_eq, htab_del);
extern htab_t htab_try_create (size_t, htab_hash, htab_eq, htab_del);
extern void htab_set_functions_ex (htab_t, htab_hash,
htab_eq, htab_del,
void *, htab_alloc_with_arg,
htab_free_with_arg);
extern void htab_delete (htab_t);
extern void htab_empty (htab_t);
extern void * htab_find (htab_t, const void *);
extern void ** htab_find_slot (htab_t, const void *, enum insert_option);
extern void * htab_find_with_hash (htab_t, const void *, hashval_t);
extern void ** htab_find_slot_with_hash (htab_t, const void *,
hashval_t, enum insert_option);
extern void htab_clear_slot (htab_t, void **);
extern void htab_remove_elt (htab_t, const void *);
extern void htab_remove_elt_with_hash (htab_t, const void *, hashval_t);
extern void htab_traverse (htab_t, htab_trav, void *);
extern void htab_traverse_noresize (htab_t, htab_trav, void *);
extern size_t htab_size (htab_t);
extern size_t htab_elements (htab_t);
extern double htab_collisions (htab_t);
extern htab_hash htab_hash_pointer;
extern htab_eq htab_eq_pointer;
extern hashval_t htab_hash_string (const void *);
extern hashval_t iterative_hash (const void *, size_t, hashval_t);
}
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h" 2
extern "C" {
# 84 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/filenames.h"
extern int filename_cmp (const char *s1, const char *s2);
extern int filename_ncmp (const char *s1, const char *s2,
size_t n);
extern hashval_t filename_hash (const void *s);
extern int filename_eq (const void *s1, const void *s2);
extern int canonical_filename_eq (const char *a, const char *b);
}
# 672 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 683 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/usr/include/dlfcn.h" 1 3 4
# 24 "/usr/include/dlfcn.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 25 "/usr/include/dlfcn.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/dlfcn.h" 1 3 4
# 57 "/usr/include/x86_64-linux-gnu/bits/dlfcn.h" 3 4
# 57 "/usr/include/x86_64-linux-gnu/bits/dlfcn.h" 3 4
extern "C" {
extern void _dl_mcount_wrapper_check (void *__selfpc) throw ();
}
# 28 "/usr/include/dlfcn.h" 2 3 4
# 44 "/usr/include/dlfcn.h" 3 4
typedef long int Lmid_t;
extern "C" {
extern void *dlopen (const char *__file, int __mode) throw ();
extern int dlclose (void *__handle) throw () __attribute__ ((__nonnull__ (1)));
extern void *dlsym (void *__restrict __handle,
const char *__restrict __name) throw () __attribute__ ((__nonnull__ (2)));
extern void *dlmopen (Lmid_t __nsid, const char *__file, int __mode) throw ();
extern void *dlvsym (void *__restrict __handle,
const char *__restrict __name,
const char *__restrict __version)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *dlerror (void) throw ();
typedef struct
{
const char *dli_fname;
void *dli_fbase;
const char *dli_sname;
void *dli_saddr;
} Dl_info;
extern int dladdr (const void *__address, Dl_info *__info)
throw () __attribute__ ((__nonnull__ (2)));
extern int dladdr1 (const void *__address, Dl_info *__info,
void **__extra_info, int __flags) throw () __attribute__ ((__nonnull__ (2)));
enum
{
RTLD_DL_SYMENT = 1,
RTLD_DL_LINKMAP = 2
};
extern int dlinfo (void *__restrict __handle,
int __request, void *__restrict __arg)
throw () __attribute__ ((__nonnull__ (1, 3)));
enum
{
RTLD_DI_LMID = 1,
RTLD_DI_LINKMAP = 2,
RTLD_DI_CONFIGADDR = 3,
RTLD_DI_SERINFO = 4,
RTLD_DI_SERINFOSIZE = 5,
RTLD_DI_ORIGIN = 6,
RTLD_DI_PROFILENAME = 7,
RTLD_DI_PROFILEOUT = 8,
RTLD_DI_TLS_MODID = 9,
RTLD_DI_TLS_DATA = 10,
RTLD_DI_MAX = 10
};
typedef struct
{
char *dls_name;
unsigned int dls_flags;
} Dl_serpath;
typedef struct
{
size_t dls_size;
unsigned int dls_cnt;
__extension__ union
{
Dl_serpath dls_serpath[0];
Dl_serpath __dls_serpath_pad[1];
};
} Dl_serinfo;
}
# 684 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/usr/include/x86_64-linux-gnu/gmp.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
# 1 "/usr/include/c++/10/iosfwd" 1 3 4
# 36 "/usr/include/c++/10/iosfwd" 3 4
# 37 "/usr/include/c++/10/iosfwd" 3
# 1 "/usr/include/c++/10/bits/stringfwd.h" 1 3
# 37 "/usr/include/c++/10/bits/stringfwd.h" 3
# 38 "/usr/include/c++/10/bits/stringfwd.h" 3
# 1 "/usr/include/c++/10/bits/memoryfwd.h" 1 3
# 46 "/usr/include/c++/10/bits/memoryfwd.h" 3
# 47 "/usr/include/c++/10/bits/memoryfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/usr/include/c++/10/bits/memoryfwd.h" 3
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
# 41 "/usr/include/c++/10/bits/stringfwd.h" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<wchar_t>;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
}
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
# 93 "/usr/include/c++/10/bits/stringfwd.h" 3
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
# 40 "/usr/include/c++/10/iosfwd" 2 3
# 1 "/usr/include/c++/10/bits/postypes.h" 1 3
# 38 "/usr/include/c++/10/bits/postypes.h" 3
# 39 "/usr/include/c++/10/bits/postypes.h" 3
# 1 "/usr/include/c++/10/cwchar" 1 3
# 39 "/usr/include/c++/10/cwchar" 3
# 40 "/usr/include/c++/10/cwchar" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 27 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 36 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 1 3 4
# 20 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 3 4
typedef unsigned int wint_t;
# 42 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h" 1 3 4
typedef __mbstate_t mbstate_t;
# 43 "/usr/include/wchar.h" 2 3 4
# 79 "/usr/include/wchar.h" 3 4
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
# 181 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
# 240 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern wint_t __btowc_alias (int __c) __asm ("btowc");
extern __inline __attribute__ ((__gnu_inline__)) wint_t
__attribute__ ((__leaf__)) btowc (int __c) throw ()
{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
? (wint_t) __c : __btowc_alias (__c)); }
extern int __wctob_alias (wint_t __c) __asm ("wctob");
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
? (int) __wc : __wctob_alias (__wc)); }
extern __inline __attribute__ ((__gnu_inline__)) size_t
__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
{ return (__ps != __null
? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
# 396 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
# 428 "/usr/include/wchar.h" 3 4
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
# 511 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
locale_t __loc) throw ();
# 551 "/usr/include/wchar.h" 3 4
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
# 567 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf")
;
extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf")
;
extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () __asm__ ("" "__isoc99_swscanf")
;
# 671 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf")
;
extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf")
;
extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vswscanf")
;
# 726 "/usr/include/wchar.h" 3 4
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
# 781 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 807 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 817 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
locale_t __loc) throw ();
# 856 "/usr/include/wchar.h" 3 4
}
# 45 "/usr/include/c++/10/cwchar" 2 3
# 62 "/usr/include/c++/10/cwchar" 3
namespace std
{
using ::mbstate_t;
}
# 135 "/usr/include/c++/10/cwchar" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::wint_t;
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
using ::swprintf;
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
using ::vfwscanf;
using ::vswprintf;
using ::vswscanf;
using ::vwprintf;
using ::vwscanf;
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
using ::wcstof;
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
# 234 "/usr/include/c++/10/cwchar" 3
}
}
namespace __gnu_cxx
{
using ::wcstold;
# 260 "/usr/include/c++/10/cwchar" 3
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
# 280 "/usr/include/c++/10/cwchar" 3
namespace std
{
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
# 41 "/usr/include/c++/10/bits/postypes.h" 2 3
# 68 "/usr/include/c++/10/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 88 "/usr/include/c++/10/bits/postypes.h" 3
typedef long streamoff;
# 98 "/usr/include/c++/10/bits/postypes.h" 3
typedef ptrdiff_t streamsize;
# 111 "/usr/include/c++/10/bits/postypes.h" 3
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos()
: _M_off(0), _M_state() { }
# 133 "/usr/include/c++/10/bits/postypes.h" 3
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
fpos(const fpos&) = default;
fpos& operator=(const fpos&) = default;
~fpos() = default;
operator streamoff() const { return _M_off; }
void
state(_StateT __st)
{ _M_state = __st; }
_StateT
state() const
{ return _M_state; }
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }
template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
# 245 "/usr/include/c++/10/bits/postypes.h" 3
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
# 41 "/usr/include/c++/10/iosfwd" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/include/c++/10/iosfwd" 3
class ios_base;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
}
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_streambuf<char> streambuf;
typedef basic_istream<char> istream;
typedef basic_ostream<char> ostream;
typedef basic_iostream<char> iostream;
typedef basic_stringbuf<char> stringbuf;
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_filebuf<char> filebuf;
typedef basic_ifstream<char> ifstream;
typedef basic_ofstream<char> ofstream;
typedef basic_fstream<char> fstream;
typedef basic_ios<wchar_t> wios;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<wchar_t> wostream;
typedef basic_iostream<wchar_t> wiostream;
typedef basic_stringbuf<wchar_t> wstringbuf;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<wchar_t> wstringstream;
typedef basic_filebuf<wchar_t> wfilebuf;
typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
}
# 35 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 1 "/usr/include/c++/10/cstdio" 1 3 4
# 39 "/usr/include/c++/10/cstdio" 3 4
# 40 "/usr/include/c++/10/cstdio" 3
# 96 "/usr/include/c++/10/cstdio" 3
namespace std
{
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;
using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;
using ::tmpnam;
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
# 157 "/usr/include/c++/10/cstdio" 3
namespace __gnu_cxx
{
# 175 "/usr/include/c++/10/cstdio" 3
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;
}
namespace std
{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
}
# 36 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 55 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 56 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4
# 57 "/usr/include/x86_64-linux-gnu/gmp.h" 2 3 4
# 141 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
typedef unsigned long int mp_limb_t;
typedef long int mp_limb_signed_t;
typedef unsigned long int mp_bitcnt_t;
typedef struct
{
int _mp_alloc;
int _mp_size;
mp_limb_t *_mp_d;
} __mpz_struct;
typedef __mpz_struct MP_INT;
typedef __mpz_struct mpz_t[1];
typedef mp_limb_t * mp_ptr;
typedef const mp_limb_t * mp_srcptr;
typedef long int mp_size_t;
typedef long int mp_exp_t;
typedef struct
{
__mpz_struct _mp_num;
__mpz_struct _mp_den;
} __mpq_struct;
typedef __mpq_struct MP_RAT;
typedef __mpq_struct mpq_t[1];
typedef struct
{
int _mp_prec;
int _mp_size;
mp_exp_t _mp_exp;
mp_limb_t *_mp_d;
} __mpf_struct;
typedef __mpf_struct mpf_t[1];
typedef enum
{
GMP_RAND_ALG_DEFAULT = 0,
GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT
} gmp_randalg_t;
typedef struct
{
mpz_t _mp_seed;
gmp_randalg_t _mp_alg;
union {
void *_mp_lc;
} _mp_algdata;
} __gmp_randstate_struct;
typedef __gmp_randstate_struct gmp_randstate_t[1];
typedef const __mpz_struct *mpz_srcptr;
typedef __mpz_struct *mpz_ptr;
typedef const __mpf_struct *mpf_srcptr;
typedef __mpf_struct *mpf_ptr;
typedef const __mpq_struct *mpq_srcptr;
typedef __mpq_struct *mpq_ptr;
# 472 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern "C" {
using std::FILE;
void __gmp_set_memory_functions (void *(*) (size_t),
void *(*) (void *, size_t, size_t),
void (*) (void *, size_t)) noexcept;
void __gmp_get_memory_functions (void *(**) (size_t),
void *(**) (void *, size_t, size_t),
void (**) (void *, size_t)) noexcept;
extern const int __gmp_bits_per_limb;
extern int __gmp_errno;
extern const char * const __gmp_version;
void __gmp_randinit (gmp_randstate_t, gmp_randalg_t, ...);
void __gmp_randinit_default (gmp_randstate_t);
void __gmp_randinit_lc_2exp (gmp_randstate_t, mpz_srcptr, unsigned long int, mp_bitcnt_t);
int __gmp_randinit_lc_2exp_size (gmp_randstate_t, mp_bitcnt_t);
void __gmp_randinit_mt (gmp_randstate_t);
void __gmp_randinit_set (gmp_randstate_t, const __gmp_randstate_struct *);
void __gmp_randseed (gmp_randstate_t, mpz_srcptr);
void __gmp_randseed_ui (gmp_randstate_t, unsigned long int);
void __gmp_randclear (gmp_randstate_t);
unsigned long __gmp_urandomb_ui (gmp_randstate_t, unsigned long);
unsigned long __gmp_urandomm_ui (gmp_randstate_t, unsigned long);
int __gmp_asprintf (char **, const char *, ...);
int __gmp_fprintf (FILE *, const char *, ...);
# 554 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
int __gmp_printf (const char *, ...);
int __gmp_snprintf (char *, size_t, const char *, ...);
int __gmp_sprintf (char *, const char *, ...);
int __gmp_vasprintf (char **, const char *, va_list);
int __gmp_vfprintf (FILE *, const char *, va_list);
int __gmp_vprintf (const char *, va_list);
int __gmp_vsnprintf (char *, size_t, const char *, va_list);
int __gmp_vsprintf (char *, const char *, va_list);
int __gmp_fscanf (FILE *, const char *, ...);
int __gmp_scanf (const char *, ...);
int __gmp_sscanf (const char *, const char *, ...);
int __gmp_vfscanf (FILE *, const char *, va_list);
int __gmp_vscanf (const char *, va_list);
int __gmp_vsscanf (const char *, const char *, va_list);
void *__gmpz_realloc (mpz_ptr, mp_size_t);
void __gmpz_abs (mpz_ptr, mpz_srcptr);
void __gmpz_add (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_add_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_addmul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_addmul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_and (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_array_init (mpz_ptr, mp_size_t, mp_size_t);
void __gmpz_bin_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_bin_uiui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_cdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_cdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_cdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_cdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_cdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_cdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_cdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_cdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
unsigned long int __gmpz_cdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_clear (mpz_ptr);
void __gmpz_clears (mpz_ptr, ...);
void __gmpz_clrbit (mpz_ptr, mp_bitcnt_t);
int __gmpz_cmp (mpz_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_cmp_d (mpz_srcptr, double) __attribute__ ((__pure__));
int __gmpz_cmp_si (mpz_srcptr, signed long int) noexcept __attribute__ ((__pure__));
int __gmpz_cmp_ui (mpz_srcptr, unsigned long int) noexcept __attribute__ ((__pure__));
int __gmpz_cmpabs (mpz_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_cmpabs_d (mpz_srcptr, double) __attribute__ ((__pure__));
int __gmpz_cmpabs_ui (mpz_srcptr, unsigned long int) noexcept __attribute__ ((__pure__));
void __gmpz_com (mpz_ptr, mpz_srcptr);
void __gmpz_combit (mpz_ptr, mp_bitcnt_t);
int __gmpz_congruent_p (mpz_srcptr, mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_congruent_2exp_p (mpz_srcptr, mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
int __gmpz_congruent_ui_p (mpz_srcptr, unsigned long, unsigned long) __attribute__ ((__pure__));
void __gmpz_divexact (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_divexact_ui (mpz_ptr, mpz_srcptr, unsigned long);
int __gmpz_divisible_p (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_divisible_ui_p (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
int __gmpz_divisible_2exp_p (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
void __gmpz_dump (mpz_srcptr);
void *__gmpz_export (void *, size_t *, int, size_t, int, size_t, mpz_srcptr);
void __gmpz_fac_ui (mpz_ptr, unsigned long int);
void __gmpz_2fac_ui (mpz_ptr, unsigned long int);
void __gmpz_mfac_uiui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_primorial_ui (mpz_ptr, unsigned long int);
void __gmpz_fdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_fdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_fdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_fdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_fdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_fdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_fdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_fdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
unsigned long int __gmpz_fdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_fib_ui (mpz_ptr, unsigned long int);
void __gmpz_fib2_ui (mpz_ptr, mpz_ptr, unsigned long int);
int __gmpz_fits_sint_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_slong_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_sshort_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_uint_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_ulong_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpz_fits_ushort_p (mpz_srcptr) noexcept __attribute__ ((__pure__));
void __gmpz_gcd (mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_gcd_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_gcdext (mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
double __gmpz_get_d (mpz_srcptr) __attribute__ ((__pure__));
double __gmpz_get_d_2exp (signed long int *, mpz_srcptr);
long int __gmpz_get_si (mpz_srcptr) noexcept __attribute__ ((__pure__));
char *__gmpz_get_str (char *, int, mpz_srcptr);
unsigned long int __gmpz_get_ui (mpz_srcptr) noexcept __attribute__ ((__pure__));
mp_limb_t __gmpz_getlimbn (mpz_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_hamdist (mpz_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
void __gmpz_import (mpz_ptr, size_t, int, size_t, int, size_t, const void *);
void __gmpz_init (mpz_ptr) noexcept;
void __gmpz_init2 (mpz_ptr, mp_bitcnt_t);
void __gmpz_inits (mpz_ptr, ...) noexcept;
void __gmpz_init_set (mpz_ptr, mpz_srcptr);
void __gmpz_init_set_d (mpz_ptr, double);
void __gmpz_init_set_si (mpz_ptr, signed long int);
int __gmpz_init_set_str (mpz_ptr, const char *, int);
void __gmpz_init_set_ui (mpz_ptr, unsigned long int);
size_t __gmpz_inp_raw (mpz_ptr, FILE *);
size_t __gmpz_inp_str (mpz_ptr, FILE *, int);
int __gmpz_invert (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_ior (mpz_ptr, mpz_srcptr, mpz_srcptr);
int __gmpz_jacobi (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_kronecker_si (mpz_srcptr, long) __attribute__ ((__pure__));
int __gmpz_kronecker_ui (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
int __gmpz_si_kronecker (long, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_ui_kronecker (unsigned long, mpz_srcptr) __attribute__ ((__pure__));
void __gmpz_lcm (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_lcm_ui (mpz_ptr, mpz_srcptr, unsigned long);
void __gmpz_lucnum_ui (mpz_ptr, unsigned long int);
void __gmpz_lucnum2_ui (mpz_ptr, mpz_ptr, unsigned long int);
int __gmpz_millerrabin (mpz_srcptr, int) __attribute__ ((__pure__));
void __gmpz_mod (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_mul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_mul_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
void __gmpz_mul_si (mpz_ptr, mpz_srcptr, long int);
void __gmpz_mul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_neg (mpz_ptr, mpz_srcptr);
void __gmpz_nextprime (mpz_ptr, mpz_srcptr);
size_t __gmpz_out_raw (FILE *, mpz_srcptr);
size_t __gmpz_out_str (FILE *, int, mpz_srcptr);
int __gmpz_perfect_power_p (mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_perfect_square_p (mpz_srcptr) __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_popcount (mpz_srcptr) noexcept __attribute__ ((__pure__));
void __gmpz_pow_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_powm (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);
void __gmpz_powm_sec (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);
void __gmpz_powm_ui (mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr);
int __gmpz_probab_prime_p (mpz_srcptr, int) __attribute__ ((__pure__));
void __gmpz_random (mpz_ptr, mp_size_t);
void __gmpz_random2 (mpz_ptr, mp_size_t);
void __gmpz_realloc2 (mpz_ptr, mp_bitcnt_t);
mp_bitcnt_t __gmpz_remove (mpz_ptr, mpz_srcptr, mpz_srcptr);
int __gmpz_root (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_rootrem (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_rrandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
mp_bitcnt_t __gmpz_scan0 (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_scan1 (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
void __gmpz_set (mpz_ptr, mpz_srcptr);
void __gmpz_set_d (mpz_ptr, double);
void __gmpz_set_f (mpz_ptr, mpf_srcptr);
void __gmpz_set_q (mpz_ptr, mpq_srcptr);
void __gmpz_set_si (mpz_ptr, signed long int);
int __gmpz_set_str (mpz_ptr, const char *, int);
void __gmpz_set_ui (mpz_ptr, unsigned long int);
void __gmpz_setbit (mpz_ptr, mp_bitcnt_t);
size_t __gmpz_size (mpz_srcptr) noexcept __attribute__ ((__pure__));
size_t __gmpz_sizeinbase (mpz_srcptr, int) noexcept __attribute__ ((__pure__));
void __gmpz_sqrt (mpz_ptr, mpz_srcptr);
void __gmpz_sqrtrem (mpz_ptr, mpz_ptr, mpz_srcptr);
void __gmpz_sub (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_sub_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_ui_sub (mpz_ptr, unsigned long int, mpz_srcptr);
void __gmpz_submul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_submul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_swap (mpz_ptr, mpz_ptr) noexcept;
unsigned long int __gmpz_tdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_tdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_tdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_tdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_tdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_tdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_tdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_tdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_tdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
int __gmpz_tstbit (mpz_srcptr, mp_bitcnt_t) noexcept __attribute__ ((__pure__));
void __gmpz_ui_pow_ui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_urandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
void __gmpz_urandomm (mpz_ptr, gmp_randstate_t, mpz_srcptr);
void __gmpz_xor (mpz_ptr, mpz_srcptr, mpz_srcptr);
mp_srcptr __gmpz_limbs_read (mpz_srcptr);
mp_ptr __gmpz_limbs_write (mpz_ptr, mp_size_t);
mp_ptr __gmpz_limbs_modify (mpz_ptr, mp_size_t);
void __gmpz_limbs_finish (mpz_ptr, mp_size_t);
mpz_srcptr __gmpz_roinit_n (mpz_ptr, mp_srcptr, mp_size_t);
void __gmpq_abs (mpq_ptr, mpq_srcptr);
void __gmpq_add (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_canonicalize (mpq_ptr);
void __gmpq_clear (mpq_ptr);
void __gmpq_clears (mpq_ptr, ...);
int __gmpq_cmp (mpq_srcptr, mpq_srcptr) __attribute__ ((__pure__));
int __gmpq_cmp_si (mpq_srcptr, long, unsigned long) __attribute__ ((__pure__));
int __gmpq_cmp_ui (mpq_srcptr, unsigned long int, unsigned long int) __attribute__ ((__pure__));
int __gmpq_cmp_z (mpq_srcptr, mpz_srcptr) __attribute__ ((__pure__));
void __gmpq_div (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_div_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
int __gmpq_equal (mpq_srcptr, mpq_srcptr) noexcept __attribute__ ((__pure__));
void __gmpq_get_num (mpz_ptr, mpq_srcptr);
void __gmpq_get_den (mpz_ptr, mpq_srcptr);
double __gmpq_get_d (mpq_srcptr) __attribute__ ((__pure__));
char *__gmpq_get_str (char *, int, mpq_srcptr);
void __gmpq_init (mpq_ptr);
void __gmpq_inits (mpq_ptr, ...);
size_t __gmpq_inp_str (mpq_ptr, FILE *, int);
void __gmpq_inv (mpq_ptr, mpq_srcptr);
void __gmpq_mul (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_mul_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
void __gmpq_neg (mpq_ptr, mpq_srcptr);
size_t __gmpq_out_str (FILE *, int, mpq_srcptr);
void __gmpq_set (mpq_ptr, mpq_srcptr);
void __gmpq_set_d (mpq_ptr, double);
void __gmpq_set_den (mpq_ptr, mpz_srcptr);
void __gmpq_set_f (mpq_ptr, mpf_srcptr);
void __gmpq_set_num (mpq_ptr, mpz_srcptr);
void __gmpq_set_si (mpq_ptr, signed long int, unsigned long int);
int __gmpq_set_str (mpq_ptr, const char *, int);
void __gmpq_set_ui (mpq_ptr, unsigned long int, unsigned long int);
void __gmpq_set_z (mpq_ptr, mpz_srcptr);
void __gmpq_sub (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_swap (mpq_ptr, mpq_ptr) noexcept;
void __gmpf_abs (mpf_ptr, mpf_srcptr);
void __gmpf_add (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_add_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_ceil (mpf_ptr, mpf_srcptr);
void __gmpf_clear (mpf_ptr);
void __gmpf_clears (mpf_ptr, ...);
int __gmpf_cmp (mpf_srcptr, mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_cmp_z (mpf_srcptr, mpz_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_cmp_d (mpf_srcptr, double) __attribute__ ((__pure__));
int __gmpf_cmp_si (mpf_srcptr, signed long int) noexcept __attribute__ ((__pure__));
int __gmpf_cmp_ui (mpf_srcptr, unsigned long int) noexcept __attribute__ ((__pure__));
void __gmpf_div (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_div_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
void __gmpf_div_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_dump (mpf_srcptr);
int __gmpf_eq (mpf_srcptr, mpf_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
int __gmpf_fits_sint_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_slong_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_sshort_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_uint_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_ulong_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
int __gmpf_fits_ushort_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_floor (mpf_ptr, mpf_srcptr);
double __gmpf_get_d (mpf_srcptr) __attribute__ ((__pure__));
double __gmpf_get_d_2exp (signed long int *, mpf_srcptr);
mp_bitcnt_t __gmpf_get_default_prec (void) noexcept __attribute__ ((__pure__));
mp_bitcnt_t __gmpf_get_prec (mpf_srcptr) noexcept __attribute__ ((__pure__));
long __gmpf_get_si (mpf_srcptr) noexcept __attribute__ ((__pure__));
char *__gmpf_get_str (char *, mp_exp_t *, int, size_t, mpf_srcptr);
unsigned long __gmpf_get_ui (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_init (mpf_ptr);
void __gmpf_init2 (mpf_ptr, mp_bitcnt_t);
void __gmpf_inits (mpf_ptr, ...);
void __gmpf_init_set (mpf_ptr, mpf_srcptr);
void __gmpf_init_set_d (mpf_ptr, double);
void __gmpf_init_set_si (mpf_ptr, signed long int);
int __gmpf_init_set_str (mpf_ptr, const char *, int);
void __gmpf_init_set_ui (mpf_ptr, unsigned long int);
size_t __gmpf_inp_str (mpf_ptr, FILE *, int);
int __gmpf_integer_p (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_mul (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_mul_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
void __gmpf_mul_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_neg (mpf_ptr, mpf_srcptr);
size_t __gmpf_out_str (FILE *, int, size_t, mpf_srcptr);
void __gmpf_pow_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_random2 (mpf_ptr, mp_size_t, mp_exp_t);
void __gmpf_reldiff (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_set (mpf_ptr, mpf_srcptr);
void __gmpf_set_d (mpf_ptr, double);
void __gmpf_set_default_prec (mp_bitcnt_t) noexcept;
void __gmpf_set_prec (mpf_ptr, mp_bitcnt_t);
void __gmpf_set_prec_raw (mpf_ptr, mp_bitcnt_t) noexcept;
void __gmpf_set_q (mpf_ptr, mpq_srcptr);
void __gmpf_set_si (mpf_ptr, signed long int);
int __gmpf_set_str (mpf_ptr, const char *, int);
void __gmpf_set_ui (mpf_ptr, unsigned long int);
void __gmpf_set_z (mpf_ptr, mpz_srcptr);
size_t __gmpf_size (mpf_srcptr) noexcept __attribute__ ((__pure__));
void __gmpf_sqrt (mpf_ptr, mpf_srcptr);
void __gmpf_sqrt_ui (mpf_ptr, unsigned long int);
void __gmpf_sub (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_sub_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_swap (mpf_ptr, mpf_ptr) noexcept;
void __gmpf_trunc (mpf_ptr, mpf_srcptr);
void __gmpf_ui_div (mpf_ptr, unsigned long int, mpf_srcptr);
void __gmpf_ui_sub (mpf_ptr, unsigned long int, mpf_srcptr);
void __gmpf_urandomb (mpf_t, gmp_randstate_t, mp_bitcnt_t);
# 1465 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
mp_limb_t __gmpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) noexcept;
mp_limb_t __gmpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
int __gmpn_cmp (mp_srcptr, mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
int __gmpn_zero_p (mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
void __gmpn_divexact_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divexact_by3c (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divrem (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_divrem_1 (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divrem_2 (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);
mp_limb_t __gmpn_div_qr_1 (mp_ptr, mp_limb_t *, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_div_qr_2 (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_srcptr);
mp_size_t __gmpn_gcd (mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
mp_limb_t __gmpn_gcd_11 (mp_limb_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_gcd_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_gcdext_1 (mp_limb_signed_t *, mp_limb_signed_t *, mp_limb_t, mp_limb_t);
mp_size_t __gmpn_gcdext (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
size_t __gmpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
mp_bitcnt_t __gmpn_hamdist (mp_srcptr, mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
mp_limb_t __gmpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_limb_t __gmpn_mod_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
void __gmpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_sqr (mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_neg (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_com (mp_ptr, mp_srcptr, mp_size_t);
int __gmpn_perfect_square_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));
int __gmpn_perfect_power_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));
mp_bitcnt_t __gmpn_popcount (mp_srcptr, mp_size_t) noexcept __attribute__ ((__pure__));
mp_size_t __gmpn_pow_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_limb_t __gmpn_preinv_mod_1 (mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t) __attribute__ ((__pure__));
void __gmpn_random (mp_ptr, mp_size_t);
void __gmpn_random2 (mp_ptr, mp_size_t);
mp_limb_t __gmpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_bitcnt_t __gmpn_scan0 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
mp_bitcnt_t __gmpn_scan1 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
mp_size_t __gmpn_set_str (mp_ptr, const unsigned char *, size_t, int);
size_t __gmpn_sizeinbase (mp_srcptr, mp_size_t, int);
mp_size_t __gmpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) noexcept;
mp_limb_t __gmpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
void __gmpn_tdiv_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
void __gmpn_and_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_andn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_nand_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_ior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_iorn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_nior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_xor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_xnor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_copyd (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_zero (mp_ptr, mp_size_t);
mp_limb_t __gmpn_cnd_add_n (mp_limb_t, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_cnd_sub_n (mp_limb_t, mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sec_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_size_t __gmpn_sec_add_1_itch (mp_size_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_sec_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_size_t __gmpn_sec_sub_1_itch (mp_size_t) __attribute__ ((__pure__));
void __gmpn_cnd_swap (mp_limb_t, volatile mp_limb_t *, volatile mp_limb_t *, mp_size_t);
void __gmpn_sec_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_mul_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_sqr (mp_ptr, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_sqr_itch (mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_powm (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_bitcnt_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_powm_itch (mp_size_t, mp_bitcnt_t, mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_tabselect (volatile mp_limb_t *, volatile const mp_limb_t *, mp_size_t, mp_size_t, mp_size_t);
mp_limb_t __gmpn_sec_div_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_div_qr_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));
void __gmpn_sec_div_r (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_ptr);
mp_size_t __gmpn_sec_div_r_itch (mp_size_t, mp_size_t) __attribute__ ((__pure__));
int __gmpn_sec_invert (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_bitcnt_t, mp_ptr);
mp_size_t __gmpn_sec_invert_itch (mp_size_t) __attribute__ ((__pure__));
# 1714 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = ((__gmp_w->_mp_size) >= 0 ? (__gmp_w->_mp_size) : -(__gmp_w->_mp_size));
}
# 1738 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_fits_uint_p (mpz_srcptr __gmp_z) noexcept
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (0x7fffffff * 2U + 1U)));;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_fits_ulong_p (mpz_srcptr __gmp_z) noexcept
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (0x7fffffffffffffffL * 2UL + 1UL)));;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_fits_ushort_p (mpz_srcptr __gmp_z) noexcept
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (0x7fff * 2 + 1)));;
}
extern __inline__ __attribute__ ((__gnu_inline__))
unsigned long
__gmpz_get_ui (mpz_srcptr __gmp_z) noexcept
{
mp_ptr __gmp_p = __gmp_z->_mp_d;
mp_size_t __gmp_n = __gmp_z->_mp_size;
mp_limb_t __gmp_l = __gmp_p[0];
return (__gmp_n != 0 ? __gmp_l : 0);
# 1794 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpz_getlimbn (mpz_srcptr __gmp_z, mp_size_t __gmp_n) noexcept
{
mp_limb_t __gmp_result = 0;
if (__builtin_expect ((__gmp_n >= 0 && __gmp_n < ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size))) != 0, 1))
__gmp_result = __gmp_z->_mp_d[__gmp_n];
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpz_neg (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = - __gmp_w->_mp_size;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpz_perfect_square_p (mpz_srcptr __gmp_a)
{
mp_size_t __gmp_asize;
int __gmp_result;
__gmp_asize = __gmp_a->_mp_size;
__gmp_result = (__gmp_asize >= 0);
if (__builtin_expect ((__gmp_asize > 0) != 0, 1))
__gmp_result = __gmpn_perfect_square_p (__gmp_a->_mp_d, __gmp_asize);
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_bitcnt_t
__gmpz_popcount (mpz_srcptr __gmp_u) noexcept
{
mp_size_t __gmp_usize;
mp_bitcnt_t __gmp_result;
__gmp_usize = __gmp_u->_mp_size;
__gmp_result = (__gmp_usize < 0 ? ~ (static_cast<mp_bitcnt_t> (0)) : (static_cast<mp_bitcnt_t> (0)));
if (__builtin_expect ((__gmp_usize > 0) != 0, 1))
__gmp_result = __gmpn_popcount (__gmp_u->_mp_d, __gmp_usize);
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__))
void
__gmpz_set_q (mpz_ptr __gmp_w, mpq_srcptr __gmp_u)
{
__gmpz_tdiv_q (__gmp_w, (&((__gmp_u)->_mp_num)), (&((__gmp_u)->_mp_den)));
}
extern __inline__ __attribute__ ((__gnu_inline__))
size_t
__gmpz_size (mpz_srcptr __gmp_z) noexcept
{
return ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size));
}
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpq_abs (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpq_set (__gmp_w, __gmp_u);
__gmp_w->_mp_num._mp_size = ((__gmp_w->_mp_num._mp_size) >= 0 ? (__gmp_w->_mp_num._mp_size) : -(__gmp_w->_mp_num._mp_size));
}
extern __inline__ __attribute__ ((__gnu_inline__)) void
__gmpq_neg (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpq_set (__gmp_w, __gmp_u);
__gmp_w->_mp_num._mp_size = - __gmp_w->_mp_num._mp_size;
}
# 2136 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_add (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_add_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x + 1) & ((~ (static_cast<mp_limb_t> (0))) >> 0)) == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_add_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) noexcept
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x + (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_r) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x + 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_r) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpn_cmp (mp_srcptr __gmp_xp, mp_srcptr __gmp_yp, mp_size_t __gmp_size) noexcept
{
int __gmp_result;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_y; (__gmp_result) = 0; __gmp_i = (__gmp_size); while (--__gmp_i >= 0) { __gmp_x = (__gmp_xp)[__gmp_i]; __gmp_y = (__gmp_yp)[__gmp_i]; if (__gmp_x != __gmp_y) { (__gmp_result) = (__gmp_x > __gmp_y ? 1 : -1); break; } } } while (0);
return __gmp_result;
}
extern __inline__ __attribute__ ((__gnu_inline__))
int
__gmpn_zero_p (mp_srcptr __gmp_p, mp_size_t __gmp_n) noexcept
{
do {
if (__gmp_p[--__gmp_n] != 0)
return 0;
} while (__gmp_n != 0);
return 1;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_sub (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_sub_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x - 1) & ((~ (static_cast<mp_limb_t> (0))) >> 0)), __gmp_x == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_sub_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) noexcept
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x - (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_x) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x - 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_x) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; ; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
return __gmp_c;
}
extern __inline__ __attribute__ ((__gnu_inline__))
mp_limb_t
__gmpn_neg (mp_ptr __gmp_rp, mp_srcptr __gmp_up, mp_size_t __gmp_n)
{
while (*__gmp_up == 0)
{
*__gmp_rp = 0;
if (!--__gmp_n)
return 0;
++__gmp_up; ++__gmp_rp;
}
*__gmp_rp = (- *__gmp_up) & ((~ (static_cast<mp_limb_t> (0))) >> 0);
if (--__gmp_n)
__gmpn_com (++__gmp_rp, ++__gmp_up, __gmp_n);
return 1;
}
}
# 2285 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
std::ostream& operator<< (std::ostream &, mpz_srcptr);
std::ostream& operator<< (std::ostream &, mpq_srcptr);
std::ostream& operator<< (std::ostream &, mpf_srcptr);
std::istream& operator>> (std::istream &, mpz_ptr);
std::istream& operator>> (std::istream &, mpq_ptr);
std::istream& operator>> (std::istream &, mpf_ptr);
# 2316 "/usr/include/x86_64-linux-gnu/gmp.h" 3 4
enum
{
GMP_ERROR_NONE = 0,
GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
GMP_ERROR_DIVISION_BY_ZERO = 2,
GMP_ERROR_SQRT_OF_NEGATIVE = 4,
GMP_ERROR_INVALID_ARGUMENT = 8
};
# 689 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h" 1
# 39 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
# 39 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern "C" {
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h" 2
# 55 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern void unlock_stream (FILE *);
extern void unlock_std_streams (void);
extern FILE *fopen_unlocked (const char *, const char *);
extern FILE *fdopen_unlocked (int, const char *);
extern FILE *freopen_unlocked (const char *, const char *, FILE *);
extern char **buildargv (const char *) __attribute__ ((__malloc__));
extern void freeargv (char **);
extern char **dupargv (char * const *) __attribute__ ((__malloc__));
extern void expandargv (int *, char ***);
extern int writeargv (char * const *, FILE *);
extern int countargv (char * const *);
# 123 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
extern const char *dos_lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
extern const char *unix_lbasename (const char *) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1)));
extern char *lrealpath (const char *);
extern int is_valid_fd (int fd);
extern char *concat (const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
# 157 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char *reconcat (char *, const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
extern unsigned long concat_length (const char *, ...) __attribute__ ((__sentinel__));
extern char *concat_copy (char *, const char *, ...) __attribute__ ((__returns_nonnull__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__sentinel__));
extern char *concat_copy2 (const char *, ...) __attribute__ ((__returns_nonnull__)) __attribute__ ((__sentinel__));
extern char *libiberty_concat_ptr;
# 193 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern int fdmatch (int fd1, int fd2);
# 205 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char * getpwd (void);
# 218 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern long get_run_time (void);
extern char *make_relative_prefix (const char *, const char *,
const char *) __attribute__ ((__malloc__));
extern char *make_relative_prefix_ignore_links (const char *, const char *,
const char *) __attribute__ ((__malloc__));
extern const char *choose_tmpdir (void) __attribute__ ((__returns_nonnull__));
extern char *choose_temp_base (void) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__));
extern char *make_temp_file (const char *) __attribute__ ((__malloc__));
extern char *make_temp_file_with_prefix (const char *, const char *) __attribute__ ((__malloc__));
extern int unlink_if_ordinary (const char *);
extern const char *spaces (int count);
extern int errno_max (void);
extern const char *strerrno (int);
extern int strtoerrno (const char *);
extern char *xstrerror (int) __attribute__ ((__returns_nonnull__));
extern int signo_max (void);
# 292 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *strsigno (int);
extern int strtosigno (const char *);
extern int xatexit (void (*fn) (void));
extern void xexit (int status) __attribute__ ((__noreturn__));
extern void xmalloc_set_program_name (const char *);
extern void xmalloc_failed (size_t) __attribute__ ((__noreturn__));
extern void *xmalloc (size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (1))) __attribute__ ((warn_unused_result));
extern void *xrealloc (void *, size_t) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (2))) __attribute__ ((warn_unused_result));
extern void *xcalloc (size_t, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((alloc_size (1, 2))) __attribute__ ((warn_unused_result));
extern char *xstrdup (const char *) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
extern char *xstrndup (const char *, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
extern void *xmemdup (const void *, size_t, size_t) __attribute__ ((__malloc__)) __attribute__ ((__returns_nonnull__)) __attribute__ ((warn_unused_result));
extern double physmem_total (void);
extern double physmem_available (void);
extern unsigned int xcrc32 (const unsigned char *, int, unsigned int);
# 391 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const unsigned char _hex_value[256];
extern void hex_init (void);
# 428 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern struct pex_obj *pex_init (int flags, const char *pname,
const char *tempbase) __attribute__ ((__returns_nonnull__));
# 528 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *pex_run (struct pex_obj *obj, int flags,
const char *executable, char * const *argv,
const char *outname, const char *errname,
int *err);
# 543 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *pex_run_in_environment (struct pex_obj *obj, int flags,
const char *executable,
char * const *argv,
char * const *env,
const char *outname,
const char *errname, int *err);
extern FILE *pex_input_file (struct pex_obj *obj, int flags,
const char *in_name);
extern FILE *pex_input_pipe (struct pex_obj *obj, int binary);
extern FILE *pex_read_output (struct pex_obj *, int binary);
extern FILE *pex_read_err (struct pex_obj *, int binary);
extern int pex_get_status (struct pex_obj *, int count, int *vector);
struct pex_time
{
unsigned long user_seconds;
unsigned long user_microseconds;
unsigned long system_seconds;
unsigned long system_microseconds;
};
extern int pex_get_times (struct pex_obj *, int count,
struct pex_time *vector);
extern void pex_free (struct pex_obj *);
# 618 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern const char *pex_one (int flags, const char *executable,
char * const *argv, const char *pname,
const char *outname, const char *errname,
int *status, int *err);
# 637 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern int pexecute (const char *, char * const *, const char *,
const char *, char **, char **, int);
extern int pwait (int, int *, int);
extern void *bsearch_r (const void *, const void *,
size_t, size_t,
int (*)(const void *, const void *, void *),
void *);
# 661 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char *xasprintf (const char *, ...) __attribute__ ((__malloc__)) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1)));
# 673 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern char *xvasprintf (const char *, va_list) __attribute__ ((__malloc__)) __attribute__ ((__format__ (__printf__, 1, 0))) __attribute__ ((__nonnull__ (1)));
# 722 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern void setproctitle (const char *name, ...);
extern void stack_limit_increase (unsigned long);
# 735 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
extern void *C_alloca (size_t) __attribute__ ((__malloc__));
# 762 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/libiberty.h"
}
# 693 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
# 763 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
extern void fancy_abort (const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
# 894 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 963 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1055 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1073 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1091 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1107 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1224 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h" 1
# 77 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
typedef long __gcc_host_wide_int__;
# 141 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
static inline unsigned long
least_bit_hwi (unsigned long x)
{
return (x & -x);
}
static inline bool
pow2_or_zerop (unsigned long x)
{
return least_bit_hwi (x) == x;
}
static inline bool
pow2p_hwi (unsigned long x)
{
return x && pow2_or_zerop (x);
}
# 184 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
static inline int
clz_hwi (unsigned long x)
{
if (x == 0)
return 64;
return __builtin_clzl (x);
}
static inline int
ctz_hwi (unsigned long x)
{
if (x == 0)
return 64;
return __builtin_ctzl (x);
}
static inline int
ffs_hwi (unsigned long x)
{
return __builtin_ffsl (x);
}
static inline int
popcount_hwi (unsigned long x)
{
return __builtin_popcountl (x);
}
static inline int
floor_log2 (unsigned long x)
{
return 64 - 1 - clz_hwi (x);
}
static inline int
ceil_log2 (unsigned long x)
{
return x == 0 ? 0 : floor_log2 (x - 1) + 1;
}
static inline int
exact_log2 (unsigned long x)
{
return pow2p_hwi (x) ? ctz_hwi (x) : -1;
}
extern long abs_hwi (long);
extern unsigned long absu_hwi (long);
extern long gcd (long, long);
extern long pos_mul_hwi (long, long);
extern long mul_hwi (long, long);
extern long least_common_multiple (long, long);
static inline int
ctz_or_zero (unsigned long x)
{
return ffs_hwi (x) - 1;
}
static inline long
sext_hwi (long src, unsigned int prec)
{
if (prec == 64)
return src;
else
{
((void)(!(prec < 64) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h", 291, __FUNCTION__), 0 : 0));
int shift = 64 - prec;
return ((long) ((unsigned long) src << shift)) >> shift;
}
# 304 "/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h"
}
static inline unsigned long
zext_hwi (unsigned long src, unsigned int prec)
{
if (prec == 64)
return src;
else
{
((void)(!(prec < 64) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h", 314, __FUNCTION__), 0 : 0));
return src & ((1UL << prec) - 1);
}
}
inline long
abs_hwi (long x)
{
((void)(!(x != (long) (1UL << (64 - 1))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hwint.h", 324, __FUNCTION__), 0 : 0));
return x >= 0 ? x : -x;
}
inline unsigned long
absu_hwi (long x)
{
return x >= 0 ? (unsigned long)x : -(unsigned long)x;
}
# 1225 "/home/giulianob/gcc_git_gnu/gcc/gcc/system.h" 2
typedef int sort_r_cmp_fn (const void *, const void *, void *);
void qsort_chk (void *, size_t, size_t, sort_r_cmp_fn *, void *);
void gcc_sort_r (void *, size_t, size_t, sort_r_cmp_fn *, void *);
void gcc_qsort (void *, size_t, size_t, int (*)(const void *, const void *));
void gcc_stablesort (void *, size_t, size_t,
int (*)(const void *, const void *));
# 95 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 1
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
typedef int64_t gcov_type;
typedef uint64_t gcov_type_unsigned;
struct bitmap_obstack;
class bitmap_head;
typedef class bitmap_head *bitmap;
typedef const class bitmap_head *const_bitmap;
struct simple_bitmap_def;
typedef struct simple_bitmap_def *sbitmap;
typedef const struct simple_bitmap_def *const_sbitmap;
struct rtx_def;
typedef struct rtx_def *rtx;
typedef const struct rtx_def *const_rtx;
class scalar_mode;
class scalar_int_mode;
class scalar_float_mode;
class complex_mode;
class fixed_size_mode;
template<typename> class opt_mode;
typedef opt_mode<scalar_mode> opt_scalar_mode;
typedef opt_mode<scalar_int_mode> opt_scalar_int_mode;
typedef opt_mode<scalar_float_mode> opt_scalar_float_mode;
template<typename> struct pod_mode;
typedef pod_mode<scalar_mode> scalar_mode_pod;
typedef pod_mode<scalar_int_mode> scalar_int_mode_pod;
typedef pod_mode<fixed_size_mode> fixed_size_mode_pod;
struct rtx_def;
struct rtx_expr_list;
struct rtx_insn_list;
struct rtx_sequence;
struct rtx_insn;
struct rtx_debug_insn;
struct rtx_nonjump_insn;
struct rtx_jump_insn;
struct rtx_call_insn;
struct rtx_jump_table_data;
struct rtx_barrier;
struct rtx_code_label;
struct rtx_note;
struct rtvec_def;
typedef struct rtvec_def *rtvec;
typedef const struct rtvec_def *const_rtvec;
struct hwivec_def;
typedef struct hwivec_def *hwivec;
typedef const struct hwivec_def *const_hwivec;
union tree_node;
typedef union tree_node *tree;
typedef const union tree_node *const_tree;
struct gimple;
typedef gimple *gimple_seq;
struct gimple_stmt_iterator;
struct gcond;
struct gdebug;
struct ggoto;
struct glabel;
struct gswitch;
struct gassign;
struct gasm;
struct gcall;
struct gtransaction;
struct greturn;
struct gbind;
struct gcatch;
struct geh_filter;
struct geh_mnt;
struct geh_else;
struct gresx;
struct geh_dispatch;
struct gphi;
struct gtry;
struct gomp_atomic_load;
struct gomp_atomic_store;
struct gomp_continue;
struct gomp_critical;
struct gomp_ordered;
struct gomp_for;
struct gomp_parallel;
struct gomp_task;
struct gomp_sections;
struct gomp_single;
struct gomp_target;
struct gomp_teams;
struct symtab_node;
struct cgraph_node;
struct varpool_node;
struct cgraph_edge;
union section;
typedef union section section;
struct gcc_options;
struct cl_target_option;
struct cl_optimization;
struct cl_option;
struct cl_decoded_option;
struct cl_option_handlers;
struct diagnostic_context;
class pretty_printer;
class diagnostic_event_id_t;
template<typename T> struct array_traits;
template<typename T, typename Traits = array_traits<T>,
bool has_constant_size = Traits::has_constant_size>
class bitmap_view;
typedef unsigned char addr_space_t;
enum ir_type {
IR_GIMPLE,
IR_RTL_CFGRTL,
IR_RTL_CFGLAYOUT
};
struct cpp_reader;
struct cpp_token;
enum tls_model {
TLS_MODEL_NONE,
TLS_MODEL_EMULATED,
TLS_MODEL_REAL,
TLS_MODEL_GLOBAL_DYNAMIC = TLS_MODEL_REAL,
TLS_MODEL_LOCAL_DYNAMIC,
TLS_MODEL_INITIAL_EXEC,
TLS_MODEL_LOCAL_EXEC
};
enum offload_abi {
OFFLOAD_ABI_UNSET,
OFFLOAD_ABI_LP64,
OFFLOAD_ABI_ILP32
};
enum profile_update {
PROFILE_UPDATE_SINGLE,
PROFILE_UPDATE_ATOMIC,
PROFILE_UPDATE_PREFER_ATOMIC
};
enum profile_reproducibility {
PROFILE_REPRODUCIBILITY_SERIAL,
PROFILE_REPRODUCIBILITY_PARALLEL_RUNS,
PROFILE_REPRODUCIBILITY_MULTITHREADED
};
enum unwind_info_type
{
UI_NONE,
UI_SJLJ,
UI_DWARF2,
UI_TARGET,
UI_SEH
};
enum node_frequency {
NODE_FREQUENCY_UNLIKELY_EXECUTED,
NODE_FREQUENCY_EXECUTED_ONCE,
NODE_FREQUENCY_NORMAL,
NODE_FREQUENCY_HOT
};
enum optimization_type {
OPTIMIZE_FOR_SPEED,
OPTIMIZE_FOR_BOTH,
OPTIMIZE_FOR_SIZE
};
enum pad_direction {
PAD_NONE,
PAD_UPWARD,
PAD_DOWNWARD
};
enum var_init_status
{
VAR_INIT_STATUS_UNKNOWN,
VAR_INIT_STATUS_UNINITIALIZED,
VAR_INIT_STATUS_INITIALIZED
};
enum warn_strict_overflow_code
{
WARN_STRICT_OVERFLOW_ALL = 1,
WARN_STRICT_OVERFLOW_CONDITIONAL = 2,
WARN_STRICT_OVERFLOW_COMPARISON = 3,
WARN_STRICT_OVERFLOW_MISC = 4,
WARN_STRICT_OVERFLOW_MAGNITUDE = 5
};
typedef int alias_set_type;
class edge_def;
typedef class edge_def *edge;
typedef const class edge_def *const_edge;
struct basic_block_def;
typedef struct basic_block_def *basic_block;
typedef const struct basic_block_def *const_basic_block;
# 343 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
typedef int reg_class_t;
class rtl_opt_pass;
namespace gcc {
class context;
}
typedef std::pair <tree, tree> tree_pair;
typedef std::pair <const char *, int> string_int_pair;
template <typename ValueType>
struct kv_pair
{
const char *const name;
const ValueType value;
};
template<typename T>
struct iterator_range
{
public:
iterator_range (const T &begin, const T &end)
: m_begin (begin), m_end (end) {}
T begin () const { return m_begin; }
T end () const { return m_end; }
private:
T m_begin;
T m_end;
};
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
enum function_class {
function_c94,
function_c99_misc,
function_c99_math_complex,
function_sincos,
function_c11_misc,
function_c2x_misc
};
enum symbol_visibility
{
VISIBILITY_DEFAULT,
VISIBILITY_PROTECTED,
VISIBILITY_HIDDEN,
VISIBILITY_INTERNAL
};
enum flt_eval_method
{
FLT_EVAL_METHOD_UNPREDICTABLE = -1,
FLT_EVAL_METHOD_PROMOTE_TO_FLOAT = 0,
FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE = 1,
FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE = 2,
FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16 = 16
};
enum excess_precision_type
{
EXCESS_PRECISION_TYPE_IMPLICIT,
EXCESS_PRECISION_TYPE_STANDARD,
EXCESS_PRECISION_TYPE_FAST
};
typedef void (*gt_pointer_operator) (void *, void *);
typedef unsigned char uchar;
# 1 "./insn-modes.h" 1
enum machine_mode
{
E_VOIDmode,
E_BLKmode,
E_CCmode,
E_CCGCmode,
E_CCGOCmode,
E_CCNOmode,
E_CCGZmode,
E_CCAmode,
E_CCCmode,
E_CCOmode,
E_CCPmode,
E_CCSmode,
E_CCZmode,
E_CCFPmode,
E_BImode,
E_QImode,
E_HImode,
E_SImode,
E_DImode,
E_TImode,
E_OImode,
E_XImode,
E_P2QImode,
E_P2HImode,
E_POImode,
E_QQmode,
E_HQmode,
E_SQmode,
E_DQmode,
E_TQmode,
E_UQQmode,
E_UHQmode,
E_USQmode,
E_UDQmode,
E_UTQmode,
E_HAmode,
E_SAmode,
E_DAmode,
E_TAmode,
E_UHAmode,
E_USAmode,
E_UDAmode,
E_UTAmode,
E_SFmode,
E_DFmode,
E_XFmode,
E_TFmode,
E_SDmode,
E_DDmode,
E_TDmode,
E_CQImode,
E_CP2QImode,
E_CHImode,
E_CP2HImode,
E_CSImode,
E_CDImode,
E_CTImode,
E_CPOImode,
E_COImode,
E_CXImode,
E_SCmode,
E_DCmode,
E_XCmode,
E_TCmode,
E_V2QImode,
E_V4QImode,
E_V2HImode,
E_V1SImode,
E_V8QImode,
E_V4HImode,
E_V2SImode,
E_V1DImode,
E_V12QImode,
E_V6HImode,
E_V14QImode,
E_V16QImode,
E_V8HImode,
E_V4SImode,
E_V2DImode,
E_V1TImode,
E_V32QImode,
E_V16HImode,
E_V8SImode,
E_V4DImode,
E_V2TImode,
E_V64QImode,
E_V32HImode,
E_V16SImode,
E_V8DImode,
E_V4TImode,
E_V128QImode,
E_V64HImode,
E_V32SImode,
E_V16DImode,
E_V8TImode,
E_V64SImode,
E_V2SFmode,
E_V4SFmode,
E_V2DFmode,
E_V8SFmode,
E_V4DFmode,
E_V2TFmode,
E_V16SFmode,
E_V8DFmode,
E_V4TFmode,
E_V32SFmode,
E_V16DFmode,
E_V8TFmode,
E_V64SFmode,
E_V32DFmode,
E_V16TFmode,
MAX_MACHINE_MODE,
MIN_MODE_RANDOM = E_VOIDmode,
MAX_MODE_RANDOM = E_BLKmode,
MIN_MODE_CC = E_CCmode,
MAX_MODE_CC = E_CCFPmode,
MIN_MODE_INT = E_QImode,
MAX_MODE_INT = E_XImode,
MIN_MODE_PARTIAL_INT = E_P2QImode,
MAX_MODE_PARTIAL_INT = E_POImode,
MIN_MODE_FRACT = E_QQmode,
MAX_MODE_FRACT = E_TQmode,
MIN_MODE_UFRACT = E_UQQmode,
MAX_MODE_UFRACT = E_UTQmode,
MIN_MODE_ACCUM = E_HAmode,
MAX_MODE_ACCUM = E_TAmode,
MIN_MODE_UACCUM = E_UHAmode,
MAX_MODE_UACCUM = E_UTAmode,
MIN_MODE_FLOAT = E_SFmode,
MAX_MODE_FLOAT = E_TFmode,
MIN_MODE_DECIMAL_FLOAT = E_SDmode,
MAX_MODE_DECIMAL_FLOAT = E_TDmode,
MIN_MODE_COMPLEX_INT = E_CQImode,
MAX_MODE_COMPLEX_INT = E_CXImode,
MIN_MODE_COMPLEX_FLOAT = E_SCmode,
MAX_MODE_COMPLEX_FLOAT = E_TCmode,
MIN_MODE_VECTOR_BOOL = E_VOIDmode,
MAX_MODE_VECTOR_BOOL = E_VOIDmode,
MIN_MODE_VECTOR_INT = E_V2QImode,
MAX_MODE_VECTOR_INT = E_V64SImode,
MIN_MODE_VECTOR_FRACT = E_VOIDmode,
MAX_MODE_VECTOR_FRACT = E_VOIDmode,
MIN_MODE_VECTOR_UFRACT = E_VOIDmode,
MAX_MODE_VECTOR_UFRACT = E_VOIDmode,
MIN_MODE_VECTOR_ACCUM = E_VOIDmode,
MAX_MODE_VECTOR_ACCUM = E_VOIDmode,
MIN_MODE_VECTOR_UACCUM = E_VOIDmode,
MAX_MODE_VECTOR_UACCUM = E_VOIDmode,
MIN_MODE_VECTOR_FLOAT = E_V2SFmode,
MAX_MODE_VECTOR_FLOAT = E_V16TFmode,
NUM_MACHINE_MODES = MAX_MACHINE_MODE
};
# 450 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/signop.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/signop.h"
enum signop {
SIGNED,
UNSIGNED
};
# 451 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 1
# 314 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> class generic_wide_int;
template <int N> class fixed_wide_int_storage;
class wide_int_storage;
typedef generic_wide_int <wide_int_storage> wide_int;
typedef generic_wide_int < fixed_wide_int_storage <((64 + 4 + 64 - 1) & ~(64 - 1))> > offset_int;
typedef generic_wide_int < fixed_wide_int_storage <(((160 + 64) / 64) * 64)> > widest_int;
typedef generic_wide_int < fixed_wide_int_storage <(((160 + 64) / 64) * 64) * 2> > widest2_int;
template <bool SE, bool HDP = true>
class wide_int_ref_storage;
typedef generic_wide_int <wide_int_ref_storage <false> > wide_int_ref;
# 348 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
namespace wi
{
# 358 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
enum overflow_type {
OVF_NONE = 0,
OVF_UNDERFLOW = -1,
OVF_OVERFLOW = 1,
OVF_UNKNOWN = 2
};
enum precision_type {
FLEXIBLE_PRECISION,
VAR_PRECISION,
CONST_PRECISION
};
# 403 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> struct int_traits;
template <typename T1, typename T2,
enum precision_type P1 = int_traits <T1>::precision_type,
enum precision_type P2 = int_traits <T2>::precision_type>
struct binary_traits;
template <typename T1, typename T2>
struct binary_traits <T1, T2, FLEXIBLE_PRECISION, FLEXIBLE_PRECISION>
{
typedef widest_int result_type;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, FLEXIBLE_PRECISION, VAR_PRECISION>
{
typedef wide_int result_type;
typedef result_type operator_result;
typedef bool predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, FLEXIBLE_PRECISION, CONST_PRECISION>
{
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T2>::precision> > result_type;
typedef result_type operator_result;
typedef bool predicate_result;
typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, VAR_PRECISION, FLEXIBLE_PRECISION>
{
typedef wide_int result_type;
typedef result_type operator_result;
typedef bool predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, CONST_PRECISION, FLEXIBLE_PRECISION>
{
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T1>::precision> > result_type;
typedef result_type operator_result;
typedef bool predicate_result;
typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, CONST_PRECISION, CONST_PRECISION>
{
static_assert ((int_traits <T1>::precision == int_traits <T2>::precision), "int_traits <T1>::precision == int_traits <T2>::precision");
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T1>::precision> > result_type;
typedef result_type operator_result;
typedef bool predicate_result;
typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
template <typename T1, typename T2>
struct binary_traits <T1, T2, VAR_PRECISION, VAR_PRECISION>
{
typedef wide_int result_type;
typedef result_type operator_result;
typedef bool predicate_result;
};
}
namespace wi
{
template <typename T>
unsigned int get_precision (const T &);
template <typename T1, typename T2>
unsigned int get_binary_precision (const T1 &, const T2 &);
template <typename T1, typename T2>
void copy (T1 &, const T2 &);
# 512 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> bool fits_shwi_p (const T &);
template <typename T> bool fits_uhwi_p (const T &);
template <typename T> bool neg_p (const T &, signop = SIGNED);
template <typename T>
long sign_mask (const T &);
template <typename T1, typename T2> bool eq_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool ne_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool lt_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool lts_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool ltu_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool le_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool les_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool leu_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool gt_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool gts_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool gtu_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool ge_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2> bool ges_p (const T1 &, const T2 &);
template <typename T1, typename T2> bool geu_p (const T1 &, const T2 &);
template <typename T1, typename T2>
int cmp (const T1 &, const T2 &, signop);
template <typename T1, typename T2>
int cmps (const T1 &, const T2 &);
template <typename T1, typename T2>
int cmpu (const T1 &, const T2 &);
template <typename T> typename wi::binary_traits <T, T>::result_type bit_not (const T &);
template <typename T> typename wi::binary_traits <T, T>::result_type neg (const T &);
template <typename T> typename wi::binary_traits <T, T>::result_type neg (const T &, overflow_type *);
template <typename T> typename wi::binary_traits <T, T>::result_type abs (const T &);
template <typename T> typename wi::binary_traits <T, T>::result_type ext (const T &, unsigned int, signop);
template <typename T> typename wi::binary_traits <T, T>::result_type sext (const T &, unsigned int);
template <typename T> typename wi::binary_traits <T, T>::result_type zext (const T &, unsigned int);
template <typename T> typename wi::binary_traits <T, T>::result_type set_bit (const T &, unsigned int);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type min (const T1 &, const T2 &, signop);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smin (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umin (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type max (const T1 &, const T2 &, signop);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smax (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umax (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_and (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_and_not (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_or (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_or_not (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type bit_xor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type add (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type add (const T1 &, const T2 &, signop, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sub (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sub (const T1 &, const T2 &, signop, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul (const T1 &, const T2 &, signop, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smul (const T1 &, const T2 &, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umul (const T1 &, const T2 &, overflow_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mul_high (const T1 &, const T2 &, signop);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_trunc (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sdiv_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_floor (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_floor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type sdiv_floor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_ceil (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type udiv_ceil (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type div_round (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type divmod_trunc (const T1 &, const T2 &, signop,
typename wi::binary_traits <T1, T2>::result_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type gcd (const T1 &, const T2 &, signop = UNSIGNED);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_trunc (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type smod_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umod_trunc (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_floor (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type umod_floor (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_ceil (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T2>::result_type mod_round (const T1 &, const T2 &, signop,
overflow_type * = 0);
template <typename T1, typename T2>
bool multiple_of_p (const T1 &, const T2 &, signop);
template <typename T1, typename T2>
bool multiple_of_p (const T1 &, const T2 &, signop,
typename wi::binary_traits <T1, T2>::result_type *);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lshift (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lrshift (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type arshift (const T1 &, const T2 &);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type rshift (const T1 &, const T2 &, signop sgn);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type lrotate (const T1 &, const T2 &, unsigned int = 0);
template <typename T1, typename T2> typename wi::binary_traits <T1, T1>::result_type rrotate (const T1 &, const T2 &, unsigned int = 0);
bool only_sign_bit_p (const wide_int_ref &, unsigned int);
bool only_sign_bit_p (const wide_int_ref &);
int clz (const wide_int_ref &);
int clrsb (const wide_int_ref &);
int ctz (const wide_int_ref &);
int exact_log2 (const wide_int_ref &);
int floor_log2 (const wide_int_ref &);
int ffs (const wide_int_ref &);
int popcount (const wide_int_ref &);
int parity (const wide_int_ref &);
template <typename T>
unsigned long extract_uhwi (const T &, unsigned int, unsigned int);
template <typename T>
unsigned int min_precision (const T &, signop);
static inline void accumulate_overflow (overflow_type &, overflow_type);
}
namespace wi
{
class storage_ref
{
public:
storage_ref () {}
storage_ref (const long *, unsigned int, unsigned int);
const long *val;
unsigned int len;
unsigned int precision;
unsigned int get_len () const;
unsigned int get_precision () const;
const long *get_val () const;
};
}
inline::wi::storage_ref::storage_ref (const long *val_in,
unsigned int len_in,
unsigned int precision_in)
: val (val_in), len (len_in), precision (precision_in)
{
}
inline unsigned int
wi::storage_ref::get_len () const
{
return len;
}
inline unsigned int
wi::storage_ref::get_precision () const
{
return precision;
}
inline const long *
wi::storage_ref::get_val () const
{
return val;
}
# 711 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename storage>
class generic_wide_int : public storage
{
public:
generic_wide_int ();
template <typename T>
generic_wide_int (const T &);
template <typename T>
generic_wide_int (const T &, unsigned int);
long to_shwi (unsigned int) const;
long to_shwi () const;
unsigned long to_uhwi (unsigned int) const;
unsigned long to_uhwi () const;
long to_short_addr () const;
long sign_mask () const;
long elt (unsigned int) const;
long sext_elt (unsigned int) const;
unsigned long ulow () const;
unsigned long uhigh () const;
long slow () const;
long shigh () const;
template <typename T>
generic_wide_int &operator = (const T &);
# 754 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T> generic_wide_int &operator &= (const T &c) { return (*this = wi::bit_and (*this, c)); }
template <typename T> generic_wide_int &operator |= (const T &c) { return (*this = wi::bit_or (*this, c)); }
template <typename T> generic_wide_int &operator ^= (const T &c) { return (*this = wi::bit_xor (*this, c)); }
template <typename T> generic_wide_int &operator += (const T &c) { return (*this = wi::add (*this, c)); }
template <typename T> generic_wide_int &operator -= (const T &c) { return (*this = wi::sub (*this, c)); }
template <typename T> generic_wide_int &operator *= (const T &c) { return (*this = wi::mul (*this, c)); }
template <typename T> generic_wide_int &operator <<= (const T &c) { return (*this = wi::lshift (*this, c)); }
template <typename T> generic_wide_int &operator >>= (const T &c) { return (*this = *this >> c); }
generic_wide_int &operator ++ () { *this += 1; return *this; }
generic_wide_int &operator -- () { *this += -1; return *this; }
void dump () const;
static const bool is_sign_extended
= wi::int_traits <generic_wide_int <storage> >::is_sign_extended;
};
template <typename storage>
inline generic_wide_int <storage>::generic_wide_int () {}
template <typename storage>
template <typename T>
inline generic_wide_int <storage>::generic_wide_int (const T &x)
: storage (x)
{
}
template <typename storage>
template <typename T>
inline generic_wide_int <storage>::generic_wide_int (const T &x,
unsigned int precision)
: storage (x, precision)
{
}
template <typename storage>
inline long
generic_wide_int <storage>::to_shwi (unsigned int precision) const
{
if (precision < 64)
return sext_hwi (this->get_val ()[0], precision);
else
return this->get_val ()[0];
}
template <typename storage>
inline long
generic_wide_int <storage>::to_shwi () const
{
if (is_sign_extended)
return this->get_val ()[0];
else
return to_shwi (this->get_precision ());
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::to_uhwi (unsigned int precision) const
{
if (precision < 64)
return zext_hwi (this->get_val ()[0], precision);
else
return this->get_val ()[0];
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::to_uhwi () const
{
return to_uhwi (this->get_precision ());
}
template <typename storage>
inline long
generic_wide_int <storage>::to_short_addr () const
{
return this->get_val ()[0];
}
template <typename storage>
inline long
generic_wide_int <storage>::sign_mask () const
{
unsigned int len = this->get_len ();
((void)(!(len > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h", 855, __FUNCTION__), 0 : 0));
unsigned long high = this->get_val ()[len - 1];
if (!is_sign_extended)
{
unsigned int precision = this->get_precision ();
int excess = len * 64 - precision;
if (excess > 0)
high <<= excess;
}
return (long) (high) < 0 ? -1 : 0;
}
template <typename storage>
inline long
generic_wide_int <storage>::slow () const
{
return this->get_val ()[0];
}
template <typename storage>
inline long
generic_wide_int <storage>::shigh () const
{
return this->get_val ()[this->get_len () - 1];
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::ulow () const
{
return this->get_val ()[0];
}
template <typename storage>
inline unsigned long
generic_wide_int <storage>::uhigh () const
{
return this->get_val ()[this->get_len () - 1];
}
template <typename storage>
inline long
generic_wide_int <storage>::elt (unsigned int i) const
{
if (i >= this->get_len ())
return sign_mask ();
else
return this->get_val ()[i];
}
template <typename storage>
inline long
generic_wide_int <storage>::sext_elt (unsigned int i) const
{
long elt_i = elt (i);
if (!is_sign_extended)
{
unsigned int precision = this->get_precision ();
unsigned int lsb = i * 64;
if (precision - lsb < 64)
elt_i = sext_hwi (elt_i, precision - lsb);
}
return elt_i;
}
template <typename storage>
template <typename T>
inline generic_wide_int <storage> &
generic_wide_int <storage>::operator = (const T &x)
{
storage::operator = (x);
return *this;
}
template <typename storage>
void
generic_wide_int <storage>::dump () const
{
unsigned int len = this->get_len ();
const long *val = this->get_val ();
unsigned int precision = this->get_precision ();
fprintf (
# 949 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 949 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "[");
if (len * 64 < precision)
fprintf (
# 951 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 951 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "...,");
for (unsigned int i = 0; i < len - 1; ++i)
fprintf (
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "%#"
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
"l" "x"
# 953 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
",", val[len - 1 - i]);
fprintf (
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
stderr
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
, "%#"
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h" 3 4
"l" "x"
# 954 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
"], precision = %d\n",
val[0], precision);
}
namespace wi
{
template <typename storage>
struct int_traits < generic_wide_int <storage> >
: public wi::int_traits <storage>
{
static unsigned int get_precision (const generic_wide_int <storage> &);
static wi::storage_ref decompose (long *, unsigned int,
const generic_wide_int <storage> &);
};
}
template <typename storage>
inline unsigned int
wi::int_traits < generic_wide_int <storage> >::
get_precision (const generic_wide_int <storage> &x)
{
return x.get_precision ();
}
template <typename storage>
inline wi::storage_ref
wi::int_traits < generic_wide_int <storage> >::
decompose (long *, unsigned int precision,
const generic_wide_int <storage> &x)
{
((void)(!(precision == x.get_precision ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h", 984, __FUNCTION__), 0 : 0));
return wi::storage_ref (x.get_val (), x.get_len (), precision);
}
template <bool SE, bool HDP>
class wide_int_ref_storage : public wi::storage_ref
{
private:
long scratch[2];
public:
wide_int_ref_storage () {}
wide_int_ref_storage (const wi::storage_ref &);
template <typename T>
wide_int_ref_storage (const T &);
template <typename T>
wide_int_ref_storage (const T &, unsigned int);
};
template <bool SE, bool HDP>
inline wide_int_ref_storage <SE, HDP>::
wide_int_ref_storage (const wi::storage_ref &x)
: storage_ref (x)
{}
template <bool SE, bool HDP>
template <typename T>
inline wide_int_ref_storage <SE, HDP>::wide_int_ref_storage (const T &x)
: storage_ref (wi::int_traits <T>::decompose (scratch,
wi::get_precision (x), x))
{
}
template <bool SE, bool HDP>
template <typename T>
inline wide_int_ref_storage <SE, HDP>::
wide_int_ref_storage (const T &x, unsigned int precision)
: storage_ref (wi::int_traits <T>::decompose (scratch, precision, x))
{
}
namespace wi
{
template <bool SE, bool HDP>
struct int_traits <wide_int_ref_storage <SE, HDP> >
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = HDP;
static const bool is_sign_extended = SE;
};
}
namespace wi
{
unsigned int force_to_size (long *, const long *,
unsigned int, unsigned int, unsigned int,
signop sgn);
unsigned int from_array (long *, const long *,
unsigned int, unsigned int, bool = true);
}
class wide_int_storage
{
private:
long val[((160 + 64) / 64)];
unsigned int len;
unsigned int precision;
public:
wide_int_storage ();
template <typename T>
wide_int_storage (const T &);
unsigned int get_precision () const;
const long *get_val () const;
unsigned int get_len () const;
long *write_val ();
void set_len (unsigned int, bool = false);
template <typename T>
wide_int_storage &operator = (const T &);
static wide_int from (const wide_int_ref &, unsigned int, signop);
static wide_int from_array (const long *, unsigned int,
unsigned int, bool = true);
static wide_int create (unsigned int);
wide_int bswap () const;
};
namespace wi
{
template <>
struct int_traits <wide_int_storage>
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
template <typename T1, typename T2>
static wide_int get_binary_result (const T1 &, const T2 &);
};
}
inline wide_int_storage::wide_int_storage () {}
template <typename T>
inline wide_int_storage::wide_int_storage (const T &x)
{
{ static_assert ((!wi::int_traits<T>::host_dependent_precision), "!wi::int_traits<T>::host_dependent_precision"); }
{ static_assert ((wi::int_traits<T>::precision_type != wi::CONST_PRECISION), "wi::int_traits<T>::precision_type != wi::CONST_PRECISION"); }
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
precision = xi.precision;
wi::copy (*this, xi);
}
template <typename T>
inline wide_int_storage&
wide_int_storage::operator = (const T &x)
{
{ static_assert ((!wi::int_traits<T>::host_dependent_precision), "!wi::int_traits<T>::host_dependent_precision"); }
{ static_assert ((wi::int_traits<T>::precision_type != wi::CONST_PRECISION), "wi::int_traits<T>::precision_type != wi::CONST_PRECISION"); }
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
precision = xi.precision;
wi::copy (*this, xi);
return *this;
}
inline unsigned int
wide_int_storage::get_precision () const
{
return precision;
}
inline const long *
wide_int_storage::get_val () const
{
return val;
}
inline unsigned int
wide_int_storage::get_len () const
{
return len;
}
inline long *
wide_int_storage::write_val ()
{
return val;
}
inline void
wide_int_storage::set_len (unsigned int l, bool is_sign_extended)
{
len = l;
if (!is_sign_extended && len * 64 > precision)
val[len - 1] = sext_hwi (val[len - 1],
precision % 64);
}
inline wide_int
wide_int_storage::from (const wide_int_ref &x, unsigned int precision,
signop sgn)
{
wide_int result = wide_int::create (precision);
result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
x.precision, precision, sgn));
return result;
}
inline wide_int
wide_int_storage::from_array (const long *val, unsigned int len,
unsigned int precision, bool need_canon_p)
{
wide_int result = wide_int::create (precision);
result.set_len (wi::from_array (result.write_val (), val, len, precision,
need_canon_p));
return result;
}
inline wide_int
wide_int_storage::create (unsigned int precision)
{
wide_int x;
x.precision = precision;
return x;
}
template <typename T1, typename T2>
inline wide_int
wi::int_traits <wide_int_storage>::get_binary_result (const T1 &x, const T2 &y)
{
static_assert ((wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION), "wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION")
;
if (wi::int_traits <T1>::precision_type == FLEXIBLE_PRECISION)
return wide_int::create (wi::get_precision (y));
else
return wide_int::create (wi::get_precision (x));
}
template <int N>
class fixed_wide_int_storage
{
private:
long val[(N + 64 + 1) / 64];
unsigned int len;
public:
fixed_wide_int_storage ();
template <typename T>
fixed_wide_int_storage (const T &);
unsigned int get_precision () const;
const long *get_val () const;
unsigned int get_len () const;
long *write_val ();
void set_len (unsigned int, bool = false);
static generic_wide_int < fixed_wide_int_storage <N> > from (const wide_int_ref &, signop);
static generic_wide_int < fixed_wide_int_storage <N> > from_array (const long *, unsigned int,
bool = true);
};
namespace wi
{
template <int N>
struct int_traits < fixed_wide_int_storage <N> >
{
static const enum precision_type precision_type = CONST_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
static const unsigned int precision = N;
template <typename T1, typename T2>
static generic_wide_int < fixed_wide_int_storage <N> > get_binary_result (const T1 &, const T2 &);
};
}
template <int N>
inline fixed_wide_int_storage <N>::fixed_wide_int_storage () {}
template <int N>
template <typename T>
inline fixed_wide_int_storage <N>::fixed_wide_int_storage (const T &x)
{
typename wi::binary_traits <T, generic_wide_int < fixed_wide_int_storage <N> > >::result_type *assertion __attribute__ ((__unused__));
wi::copy (*this, generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > (x, N));
}
template <int N>
inline unsigned int
fixed_wide_int_storage <N>::get_precision () const
{
return N;
}
template <int N>
inline const long *
fixed_wide_int_storage <N>::get_val () const
{
return val;
}
template <int N>
inline unsigned int
fixed_wide_int_storage <N>::get_len () const
{
return len;
}
template <int N>
inline long *
fixed_wide_int_storage <N>::write_val ()
{
return val;
}
template <int N>
inline void
fixed_wide_int_storage <N>::set_len (unsigned int l, bool)
{
len = l;
static_assert ((N % 64 == 0), "N % HOST_BITS_PER_WIDE_INT == 0");
}
template <int N>
inline generic_wide_int < fixed_wide_int_storage <N> >
fixed_wide_int_storage <N>::from (const wide_int_ref &x, signop sgn)
{
generic_wide_int < fixed_wide_int_storage <N> > result;
result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
x.precision, N, sgn));
return result;
}
template <int N>
inline generic_wide_int < fixed_wide_int_storage <N> >
fixed_wide_int_storage <N>::from_array (const long *val,
unsigned int len,
bool need_canon_p)
{
generic_wide_int < fixed_wide_int_storage <N> > result;
result.set_len (wi::from_array (result.write_val (), val, len,
N, need_canon_p));
return result;
}
template <int N>
template <typename T1, typename T2>
inline generic_wide_int < fixed_wide_int_storage <N> >
wi::int_traits < fixed_wide_int_storage <N> >::
get_binary_result (const T1 &, const T2 &)
{
return generic_wide_int < fixed_wide_int_storage <N> > ();
}
class trailing_wide_int_storage
{
private:
unsigned int m_precision;
unsigned char *m_len;
long *m_val;
public:
trailing_wide_int_storage (unsigned int, unsigned char *, long *);
unsigned int get_len () const;
unsigned int get_precision () const;
const long *get_val () const;
long *write_val ();
void set_len (unsigned int, bool = false);
template <typename T>
trailing_wide_int_storage &operator = (const T &);
};
typedef generic_wide_int <trailing_wide_int_storage> trailing_wide_int;
namespace wi
{
template <>
struct int_traits <trailing_wide_int_storage>
: public int_traits <wide_int_storage> {};
}
template <int N>
struct trailing_wide_ints
{
private:
unsigned short m_precision;
unsigned char m_max_len;
unsigned char m_len[N];
long m_val[1];
public:
typedef generic_wide_int <wide_int_ref_storage <wi::int_traits <trailing_wide_int_storage>::is_sign_extended, wi::int_traits <trailing_wide_int_storage>::host_dependent_precision> > const_reference;
void set_precision (unsigned int);
unsigned int get_precision () const { return m_precision; }
trailing_wide_int operator [] (unsigned int);
const_reference operator [] (unsigned int) const;
static size_t extra_size (unsigned int);
size_t extra_size () const { return extra_size (m_precision); }
};
inline trailing_wide_int_storage::
trailing_wide_int_storage (unsigned int precision, unsigned char *len,
long *val)
: m_precision (precision), m_len (len), m_val (val)
{
}
inline unsigned int
trailing_wide_int_storage::get_len () const
{
return *m_len;
}
inline unsigned int
trailing_wide_int_storage::get_precision () const
{
return m_precision;
}
inline const long *
trailing_wide_int_storage::get_val () const
{
return m_val;
}
inline long *
trailing_wide_int_storage::write_val ()
{
return m_val;
}
inline void
trailing_wide_int_storage::set_len (unsigned int len, bool is_sign_extended)
{
*m_len = len;
if (!is_sign_extended && len * 64 > m_precision)
m_val[len - 1] = sext_hwi (m_val[len - 1],
m_precision % 64);
}
template <typename T>
inline trailing_wide_int_storage &
trailing_wide_int_storage::operator = (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, m_precision);
wi::copy (*this, xi);
return *this;
}
template <int N>
inline void
trailing_wide_ints <N>::set_precision (unsigned int precision)
{
m_precision = precision;
m_max_len = ((precision + 64 - 1)
/ 64);
}
template <int N>
inline trailing_wide_int
trailing_wide_ints <N>::operator [] (unsigned int index)
{
return trailing_wide_int_storage (m_precision, &m_len[index],
&m_val[index * m_max_len]);
}
template <int N>
inline typename trailing_wide_ints <N>::const_reference
trailing_wide_ints <N>::operator [] (unsigned int index) const
{
return wi::storage_ref (&m_val[index * m_max_len],
m_len[index], m_precision);
}
template <int N>
inline size_t
trailing_wide_ints <N>::extra_size (unsigned int precision)
{
unsigned int max_len = ((precision + 64 - 1)
/ 64);
return (N * max_len - 1) * sizeof (long);
}
# 1503 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
namespace wi
{
template <typename T, bool signed_p>
struct primitive_int_traits
{
static const enum precision_type precision_type = FLEXIBLE_PRECISION;
static const bool host_dependent_precision = true;
static const bool is_sign_extended = true;
static unsigned int get_precision (T);
static wi::storage_ref decompose (long *, unsigned int, T);
};
}
template <typename T, bool signed_p>
inline unsigned int
wi::primitive_int_traits <T, signed_p>::get_precision (T)
{
return sizeof (T) * 8;
}
template <typename T, bool signed_p>
inline wi::storage_ref
wi::primitive_int_traits <T, signed_p>::decompose (long *scratch,
unsigned int precision, T x)
{
scratch[0] = x;
if (signed_p || scratch[0] >= 0 || precision <= 64)
return wi::storage_ref (scratch, 1, precision);
scratch[1] = 0;
return wi::storage_ref (scratch, 2, precision);
}
namespace wi
{
template <>
struct int_traits <unsigned char>
: public primitive_int_traits <unsigned char, false> {};
template <>
struct int_traits <unsigned short>
: public primitive_int_traits <unsigned short, false> {};
template <>
struct int_traits <int>
: public primitive_int_traits <int, true> {};
template <>
struct int_traits <unsigned int>
: public primitive_int_traits <unsigned int, false> {};
template <>
struct int_traits <long>
: public primitive_int_traits <long, true> {};
template <>
struct int_traits <unsigned long>
: public primitive_int_traits <unsigned long, false> {};
template <>
struct int_traits <long long>
: public primitive_int_traits <long long, true> {};
template <>
struct int_traits <unsigned long long>
: public primitive_int_traits <unsigned long long, false> {};
}
namespace wi
{
class hwi_with_prec
{
public:
hwi_with_prec () {}
hwi_with_prec (long, unsigned int, signop);
long val;
unsigned int precision;
signop sgn;
};
hwi_with_prec shwi (long, unsigned int);
hwi_with_prec uhwi (unsigned long, unsigned int);
hwi_with_prec minus_one (unsigned int);
hwi_with_prec zero (unsigned int);
hwi_with_prec one (unsigned int);
hwi_with_prec two (unsigned int);
}
inline wi::hwi_with_prec::hwi_with_prec (long v, unsigned int p,
signop s)
: precision (p), sgn (s)
{
if (precision < 64)
val = sext_hwi (v, precision);
else
val = v;
}
inline wi::hwi_with_prec
wi::shwi (long val, unsigned int precision)
{
return hwi_with_prec (val, precision, SIGNED);
}
inline wi::hwi_with_prec
wi::uhwi (unsigned long val, unsigned int precision)
{
return hwi_with_prec (val, precision, UNSIGNED);
}
inline wi::hwi_with_prec
wi::minus_one (unsigned int precision)
{
return wi::shwi (-1, precision);
}
inline wi::hwi_with_prec
wi::zero (unsigned int precision)
{
return wi::shwi (0, precision);
}
inline wi::hwi_with_prec
wi::one (unsigned int precision)
{
return wi::shwi (1, precision);
}
inline wi::hwi_with_prec
wi::two (unsigned int precision)
{
return wi::shwi (2, precision);
}
namespace wi
{
template<typename T, precision_type = int_traits<T>::precision_type>
struct ints_for
{
static int zero (const T &) { return 0; }
};
template<typename T>
struct ints_for<T, VAR_PRECISION>
{
static hwi_with_prec zero (const T &);
};
}
template<typename T>
inline wi::hwi_with_prec
wi::ints_for<T, wi::VAR_PRECISION>::zero (const T &x)
{
return wi::zero (wi::get_precision (x));
}
namespace wi
{
template <>
struct int_traits <wi::hwi_with_prec>
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
static unsigned int get_precision (const wi::hwi_with_prec &);
static wi::storage_ref decompose (long *, unsigned int,
const wi::hwi_with_prec &);
};
}
inline unsigned int
wi::int_traits <wi::hwi_with_prec>::get_precision (const wi::hwi_with_prec &x)
{
return x.precision;
}
inline wi::storage_ref
wi::int_traits <wi::hwi_with_prec>::
decompose (long *scratch, unsigned int precision,
const wi::hwi_with_prec &x)
{
((void)(!(precision == x.precision) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h", 1700, __FUNCTION__), 0 : 0));
scratch[0] = x.val;
if (x.sgn == SIGNED || x.val >= 0 || precision <= 64)
return wi::storage_ref (scratch, 1, precision);
scratch[1] = 0;
return wi::storage_ref (scratch, 2, precision);
}
namespace wi
{
bool eq_p_large (const long *, unsigned int,
const long *, unsigned int, unsigned int);
bool lts_p_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
bool ltu_p_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
int cmps_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
int cmpu_large (const long *, unsigned int, unsigned int,
const long *, unsigned int);
unsigned int sext_large (long *, const long *,
unsigned int,
unsigned int, unsigned int);
unsigned int zext_large (long *, const long *,
unsigned int,
unsigned int, unsigned int);
unsigned int set_bit_large (long *, const long *,
unsigned int, unsigned int, unsigned int);
unsigned int lshift_large (long *, const long *,
unsigned int, unsigned int, unsigned int);
unsigned int lrshift_large (long *, const long *,
unsigned int, unsigned int, unsigned int,
unsigned int);
unsigned int arshift_large (long *, const long *,
unsigned int, unsigned int, unsigned int,
unsigned int);
unsigned int and_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int);
unsigned int and_not_large (long *, const long *,
unsigned int, const long *,
unsigned int, unsigned int);
unsigned int or_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int);
unsigned int or_not_large (long *, const long *,
unsigned int, const long *,
unsigned int, unsigned int);
unsigned int xor_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int);
unsigned int add_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int,
signop, overflow_type *);
unsigned int sub_large (long *, const long *, unsigned int,
const long *, unsigned int, unsigned int,
signop, overflow_type *);
unsigned int mul_internal (long *, const long *,
unsigned int, const long *,
unsigned int, unsigned int, signop,
overflow_type *, bool);
unsigned int divmod_internal (long *, unsigned int *,
long *, const long *,
unsigned int, unsigned int,
const long *,
unsigned int, unsigned int,
signop, overflow_type *);
}
template <typename T>
inline unsigned int
wi::get_precision (const T &x)
{
return wi::int_traits <T>::get_precision (x);
}
template <typename T1, typename T2>
inline unsigned int
wi::get_binary_precision (const T1 &x, const T2 &y)
{
return get_precision (wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::
get_binary_result (x, y));
}
template <typename T1, typename T2>
inline void
wi::copy (T1 &x, const T2 &y)
{
long *xval = x.write_val ();
const long *yval = y.get_val ();
unsigned int len = y.get_len ();
unsigned int i = 0;
do
xval[i] = yval[i];
while (++i < len);
x.set_len (len, y.is_sign_extended);
}
template <typename T>
inline bool
wi::fits_shwi_p (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
return xi.len == 1;
}
template <typename T>
inline bool
wi::fits_uhwi_p (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
if (xi.precision <= 64)
return true;
if (xi.len == 1)
return xi.slow () >= 0;
return xi.len == 2 && xi.uhigh () == 0;
}
template <typename T>
inline bool
wi::neg_p (const T &x, signop sgn)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
if (sgn == UNSIGNED)
return false;
return xi.sign_mask () < 0;
}
template <typename T>
inline long
wi::sign_mask (const T &x)
{
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x);
return xi.sign_mask ();
}
template <typename T1, typename T2>
inline bool
wi::eq_p (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (xi.is_sign_extended && yi.is_sign_extended)
{
if (xi.len != yi.len)
return false;
unsigned int i = 0;
do
if (xi.val[i] != yi.val[i])
return false;
while (++i != xi.len);
return true;
}
if (__builtin_expect (yi.len == 1, true))
{
if (xi.len != 1)
return false;
if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
return xi.val[0] == 0;
unsigned long diff = xi.val[0] ^ yi.val[0];
int excess = 64 - precision;
if (excess > 0)
diff <<= excess;
return diff == 0;
}
return eq_p_large (xi.val, xi.len, yi.val, yi.len, precision);
}
template <typename T1, typename T2>
inline bool
wi::ne_p (const T1 &x, const T2 &y)
{
return !eq_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::lts_p (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (wi::fits_shwi_p (yi))
{
if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
return neg_p (xi);
if (wi::fits_shwi_p (xi))
return xi.to_shwi () < yi.to_shwi ();
if (neg_p (xi))
return true;
return false;
}
if ((__builtin_constant_p (xi.len == 1) && (xi.len == 1)))
return !neg_p (yi);
return lts_p_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline bool
wi::ltu_p (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if ((__builtin_constant_p (yi.len == 1 && yi.val[0] >= 0) && (yi.len == 1 && yi.val[0] >= 0)))
return xi.len == 1 && xi.to_uhwi () < (unsigned long) yi.val[0];
if ((__builtin_constant_p (xi.len == 1 && xi.val[0] >= 0) && (xi.len == 1 && xi.val[0] >= 0)))
return yi.len != 1 || yi.to_uhwi () > (unsigned long) xi.val[0];
if (__builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.to_uhwi ();
unsigned long yl = yi.to_uhwi ();
return xl < yl;
}
return ltu_p_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline bool
wi::lt_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return lts_p (x, y);
else
return ltu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::les_p (const T1 &x, const T2 &y)
{
return !lts_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::leu_p (const T1 &x, const T2 &y)
{
return !ltu_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::le_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return les_p (x, y);
else
return leu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::gts_p (const T1 &x, const T2 &y)
{
return lts_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::gtu_p (const T1 &x, const T2 &y)
{
return ltu_p (y, x);
}
template <typename T1, typename T2>
inline bool
wi::gt_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return gts_p (x, y);
else
return gtu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::ges_p (const T1 &x, const T2 &y)
{
return !lts_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::geu_p (const T1 &x, const T2 &y)
{
return !ltu_p (x, y);
}
template <typename T1, typename T2>
inline bool
wi::ge_p (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return ges_p (x, y);
else
return geu_p (x, y);
}
template <typename T1, typename T2>
inline int
wi::cmps (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (wi::fits_shwi_p (yi))
{
if ((__builtin_constant_p (yi.val[0] == 0) && (yi.val[0] == 0)))
return neg_p (xi) ? -1 : !(xi.len == 1 && xi.val[0] == 0);
if (wi::fits_shwi_p (xi))
{
long xl = xi.to_shwi ();
long yl = yi.to_shwi ();
return xl < yl ? -1 : xl > yl;
}
if (neg_p (xi))
return -1;
return 1;
}
if ((__builtin_constant_p (xi.len == 1) && (xi.len == 1)))
return neg_p (yi) ? 1 : -1;
return cmps_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline int
wi::cmpu (const T1 &x, const T2 &y)
{
unsigned int precision = get_binary_precision (x, y);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if ((__builtin_constant_p (yi.len == 1 && yi.val[0] >= 0) && (yi.len == 1 && yi.val[0] >= 0)))
{
if (xi.len != 1)
return 1;
unsigned long xl = xi.to_uhwi ();
unsigned long yl = yi.val[0];
return xl < yl ? -1 : xl > yl;
}
if ((__builtin_constant_p (xi.len == 1 && xi.val[0] >= 0) && (xi.len == 1 && xi.val[0] >= 0)))
{
if (yi.len != 1)
return -1;
unsigned long xl = xi.val[0];
unsigned long yl = yi.to_uhwi ();
return xl < yl ? -1 : xl > yl;
}
if (__builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.to_uhwi ();
unsigned long yl = yi.to_uhwi ();
return xl < yl ? -1 : xl > yl;
}
return cmpu_large (xi.val, xi.len, precision, yi.val, yi.len);
}
template <typename T1, typename T2>
inline int
wi::cmp (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == SIGNED)
return cmps (x, y);
else
return cmpu (x, y);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::bit_not (const T &x)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, get_precision (result));
for (unsigned int i = 0; i < xi.len; ++i)
val[i] = ~xi.val[i];
result.set_len (xi.len);
return result;
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::neg (const T &x)
{
return sub (0, x);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::neg (const T &x, overflow_type *overflow)
{
*overflow = only_sign_bit_p (x) ? OVF_OVERFLOW : OVF_NONE;
return sub (0, x);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::abs (const T &x)
{
return neg_p (x) ? neg (x) : typename wi::binary_traits <T, T>::result_type (x);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::sext (const T &x, unsigned int offset)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (offset <= 64)
{
val[0] = sext_hwi (xi.ulow (), offset);
result.set_len (1, true);
}
else
result.set_len (sext_large (val, xi.val, xi.len, precision, offset));
return result;
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::zext (const T &x, unsigned int offset)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (offset >= precision)
{
wi::copy (result, xi);
return result;
}
if (offset < 64)
{
val[0] = zext_hwi (xi.ulow (), offset);
result.set_len (1, true);
}
else
result.set_len (zext_large (val, xi.val, xi.len, precision, offset), true);
return result;
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::ext (const T &x, unsigned int offset, signop sgn)
{
return sgn == SIGNED ? sext (x, offset) : zext (x, offset);
}
template <typename T>
inline typename wi::binary_traits <T, T>::result_type
wi::set_bit (const T &x, unsigned int bit)
{
typename wi::binary_traits <T, T>::result_type result = wi::int_traits <typename wi::binary_traits <T, T>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (precision <= 64)
{
val[0] = xi.ulow () | (1UL << bit);
result.set_len (1);
}
else
result.set_len (set_bit_large (val, xi.val, xi.len, precision, bit));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::min (const T1 &x, const T2 &y, signop sgn)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val __attribute__ ((__unused__)) = result.write_val ();
unsigned int precision = get_precision (result);
if (wi::le_p (x, y, sgn))
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > (x, precision));
else
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > (y, precision));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smin (const T1 &x, const T2 &y)
{
return wi::min (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umin (const T1 &x, const T2 &y)
{
return wi::min (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::max (const T1 &x, const T2 &y, signop sgn)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val __attribute__ ((__unused__)) = result.write_val ();
unsigned int precision = get_precision (result);
if (wi::ge_p (x, y, sgn))
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > (x, precision));
else
wi::copy (result, generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > (y, precision));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smax (const T1 &x, const T2 &y)
{
return wi::max (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umax (const T1 &x, const T2 &y)
{
return wi::max (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_and (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () & yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (and_large (val, xi.val, xi.len, yi.val, yi.len,
precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_and_not (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () & ~yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (and_not_large (val, xi.val, xi.len, yi.val, yi.len,
precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_or (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () | yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (or_large (val, xi.val, xi.len,
yi.val, yi.len, precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_or_not (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () | ~yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (or_not_large (val, xi.val, xi.len, yi.val, yi.len,
precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::bit_xor (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
if (__builtin_expect (xi.len + yi.len == 2, true))
{
val[0] = xi.ulow () ^ yi.ulow ();
result.set_len (1, is_sign_extended);
}
else
result.set_len (xor_large (val, xi.val, xi.len,
yi.val, yi.len, precision), is_sign_extended);
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::add (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
val[0] = xi.ulow () + yi.ulow ();
result.set_len (1);
}
# 2441 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
else if ((__builtin_constant_p (precision > 64) && (precision > 64))
&& __builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl + yl;
val[0] = resultl;
val[1] = (long) resultl < 0 ? 0 : -1;
result.set_len (1 + (((resultl ^ xl) & (resultl ^ yl))
>> (64 - 1)));
}
else
result.set_len (add_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
UNSIGNED, 0));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::add (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl + yl;
if (sgn == SIGNED)
{
if ((((resultl ^ xl) & (resultl ^ yl))
>> (precision - 1)) & 1)
{
if (xl > resultl)
*overflow = OVF_UNDERFLOW;
else if (xl < resultl)
*overflow = OVF_OVERFLOW;
else
*overflow = OVF_NONE;
}
else
*overflow = OVF_NONE;
}
else
*overflow = ((resultl << (64 - precision))
< (xl << (64 - precision)))
? OVF_OVERFLOW : OVF_NONE;
val[0] = resultl;
result.set_len (1);
}
else
result.set_len (add_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, overflow));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sub (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
val[0] = xi.ulow () - yi.ulow ();
result.set_len (1);
}
# 2527 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
else if ((__builtin_constant_p (precision > 64) && (precision > 64))
&& __builtin_expect (xi.len + yi.len == 2, true))
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl - yl;
val[0] = resultl;
val[1] = (long) resultl < 0 ? 0 : -1;
result.set_len (1 + (((resultl ^ xl) & (xl ^ yl))
>> (64 - 1)));
}
else
result.set_len (sub_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
UNSIGNED, 0));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sub (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
unsigned long xl = xi.ulow ();
unsigned long yl = yi.ulow ();
unsigned long resultl = xl - yl;
if (sgn == SIGNED)
{
if ((((xl ^ yl) & (resultl ^ xl)) >> (precision - 1)) & 1)
{
if (xl > yl)
*overflow = OVF_UNDERFLOW;
else if (xl < yl)
*overflow = OVF_OVERFLOW;
else
*overflow = OVF_NONE;
}
else
*overflow = OVF_NONE;
}
else
*overflow = ((resultl << (64 - precision))
> (xl << (64 - precision)))
? OVF_UNDERFLOW : OVF_NONE;
val[0] = resultl;
result.set_len (1);
}
else
result.set_len (sub_large (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, overflow));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mul (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
if (precision <= 64)
{
val[0] = xi.ulow () * yi.ulow ();
result.set_len (1);
}
else
result.set_len (mul_internal (val, xi.val, xi.len, yi.val, yi.len,
precision, UNSIGNED, 0, false));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mul (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
result.set_len (mul_internal (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, overflow, false));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smul (const T1 &x, const T2 &y, overflow_type *overflow)
{
return mul (x, y, SIGNED, overflow);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umul (const T1 &x, const T2 &y, overflow_type *overflow)
{
return mul (x, y, UNSIGNED, overflow);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mul_high (const T1 &x, const T2 &y, signop sgn)
{
typename wi::binary_traits <T1, T2>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y, precision);
result.set_len (mul_internal (val, xi.val, xi.len,
yi.val, yi.len, precision,
sgn, 0, true));
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
quotient.set_len (divmod_internal (quotient_val, 0, 0, xi.val, xi.len,
precision,
yi.val, yi.len, yi.precision,
sgn, overflow));
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sdiv_trunc (const T1 &x, const T2 &y)
{
return div_trunc (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::udiv_trunc (const T1 &x, const T2 &y)
{
return div_trunc (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
return quotient - 1;
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::sdiv_floor (const T1 &x, const T2 &y)
{
return div_floor (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::udiv_floor (const T1 &x, const T2 &y)
{
return div_floor (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
return quotient + 1;
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::udiv_ceil (const T1 &x, const T2 &y)
{
return div_ceil (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::div_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (remainder != 0)
{
if (sgn == SIGNED)
{
typename wi::binary_traits <T1, T2>::result_type abs_remainder = wi::abs (remainder);
if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
{
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
return quotient - 1;
else
return quotient + 1;
}
}
else
{
if (wi::geu_p (remainder, wi::sub (y, remainder)))
return quotient + 1;
}
}
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::divmod_trunc (const T1 &x, const T2 &y, signop sgn,
typename wi::binary_traits <T1, T2>::result_type *remainder_ptr)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn, 0));
remainder.set_len (remainder_len);
*remainder_ptr = remainder;
return quotient;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::gcd (const T1 &a, const T2 &b, signop sgn)
{
T1 x, y, z;
x = wi::abs (a);
y = wi::abs (b);
while (gt_p (x, 0, sgn))
{
z = mod_trunc (y, x, sgn);
y = x;
x = z;
}
return y;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (remainder);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
divmod_internal (0, &remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn, overflow);
remainder.set_len (remainder_len);
return remainder;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::smod_trunc (const T1 &x, const T2 &y)
{
return mod_trunc (x, y, SIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umod_trunc (const T1 &x, const T2 &y)
{
return mod_trunc (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
return remainder + y;
return remainder;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::umod_floor (const T1 &x, const T2 &y)
{
return mod_floor (x, y, UNSIGNED);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
return remainder - y;
return remainder;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::result_type
wi::mod_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
{
typename wi::binary_traits <T1, T2>::result_type quotient = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *quotient_val = quotient.write_val ();
typename wi::binary_traits <T1, T2>::result_type remainder = wi::int_traits <typename wi::binary_traits <T1, T2>::result_type>::get_binary_result (x, y); long *remainder_val = remainder.write_val ();
unsigned int precision = get_precision (quotient);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
unsigned int remainder_len;
quotient.set_len (divmod_internal (quotient_val,
&remainder_len, remainder_val,
xi.val, xi.len, precision,
yi.val, yi.len, yi.precision, sgn,
overflow));
remainder.set_len (remainder_len);
if (remainder != 0)
{
if (sgn == SIGNED)
{
typename wi::binary_traits <T1, T2>::result_type abs_remainder = wi::abs (remainder);
if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
{
if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
return remainder + y;
else
return remainder - y;
}
}
else
{
if (wi::geu_p (remainder, wi::sub (y, remainder)))
return remainder - y;
}
}
return remainder;
}
template <typename T1, typename T2>
inline bool
wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn)
{
return wi::mod_trunc (x, y, sgn) == 0;
}
template <typename T1, typename T2>
inline bool
wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn,
typename wi::binary_traits <T1, T2>::result_type *res)
{
typename wi::binary_traits <T1, T2>::result_type remainder;
typename wi::binary_traits <T1, T2>::result_type quotient
= divmod_trunc (x, y, sgn, &remainder);
if (remainder == 0)
{
*res = quotient;
return true;
}
return false;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::lshift (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
unsigned int precision = get_precision (result);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x, precision);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
if (geu_p (yi, precision))
{
val[0] = 0;
result.set_len (1);
}
else
{
unsigned int shift = yi.to_uhwi ();
# 3054 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
if ((__builtin_constant_p (xi.precision > 64) && (xi.precision > 64))
? ((__builtin_constant_p (shift < 64 - 1) && (shift < 64 - 1))
&& xi.len == 1
&& ((unsigned long) (xi.val[0]) - (unsigned long) (0) <= (unsigned long) ((~((long) (1UL << (64 - 1)))) >> shift) - (unsigned long) (0)))
: precision <= 64)
{
val[0] = xi.ulow () << shift;
result.set_len (1);
}
else
result.set_len (lshift_large (val, xi.val, xi.len,
precision, shift));
}
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::lrshift (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
if (geu_p (yi, xi.precision))
{
val[0] = 0;
result.set_len (1);
}
else
{
unsigned int shift = yi.to_uhwi ();
# 3098 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
if ((__builtin_constant_p (xi.precision > 64) && (xi.precision > 64))
? (shift < 64
&& xi.len == 1
&& xi.val[0] >= 0)
: xi.precision <= 64)
{
val[0] = xi.to_uhwi () >> shift;
result.set_len (1);
}
else
result.set_len (lrshift_large (val, xi.val, xi.len, xi.precision,
get_precision (result), shift));
}
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::arshift (const T1 &x, const T2 &y)
{
typename wi::binary_traits <T1, T1>::result_type result = wi::int_traits <typename wi::binary_traits <T1, T1>::result_type>::get_binary_result (x, x); long *val = result.write_val ();
generic_wide_int <wide_int_ref_storage <wi::int_traits <T1>::is_sign_extended, wi::int_traits <T1>::host_dependent_precision> > xi (x);
generic_wide_int <wide_int_ref_storage <wi::int_traits <T2>::is_sign_extended, wi::int_traits <T2>::host_dependent_precision> > yi (y);
if (geu_p (yi, xi.precision))
{
val[0] = sign_mask (x);
result.set_len (1);
}
else
{
unsigned int shift = yi.to_uhwi ();
if (xi.precision <= 64)
{
val[0] = sext_hwi (xi.ulow () >> shift, xi.precision - shift);
result.set_len (1, true);
}
else
result.set_len (arshift_large (val, xi.val, xi.len, xi.precision,
get_precision (result), shift));
}
return result;
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T1>::result_type
wi::rshift (const T1 &x, const T2 &y, signop sgn)
{
if (sgn == UNSIGNED)
return lrshift (x, y);
else
return arshift (x, y);
}
template <typename T1, typename T2>
typename wi::binary_traits <T1, T1>::result_type
wi::lrotate (const T1 &x, const T2 &y, unsigned int width)
{
unsigned int precision = get_binary_precision (x, x);
if (width == 0)
width = precision;
typename wi::binary_traits <T2, T2>::result_type ymod = umod_trunc (y, width);
typename wi::binary_traits <T1, T1>::result_type left = wi::lshift (x, ymod);
typename wi::binary_traits <T1, T1>::result_type right = wi::lrshift (x, wi::sub (width, ymod));
if (width != precision)
return wi::zext (left, width) | wi::zext (right, width);
return left | right;
}
template <typename T1, typename T2>
typename wi::binary_traits <T1, T1>::result_type
wi::rrotate (const T1 &x, const T2 &y, unsigned int width)
{
unsigned int precision = get_binary_precision (x, x);
if (width == 0)
width = precision;
typename wi::binary_traits <T2, T2>::result_type ymod = umod_trunc (y, width);
typename wi::binary_traits <T1, T1>::result_type right = wi::lrshift (x, ymod);
typename wi::binary_traits <T1, T1>::result_type left = wi::lshift (x, wi::sub (width, ymod));
if (width != precision)
return wi::zext (left, width) | wi::zext (right, width);
return left | right;
}
inline int
wi::parity (const wide_int_ref &x)
{
return popcount (x) & 1;
}
template <typename T>
inline unsigned long
wi::extract_uhwi (const T &x, unsigned int bitpos, unsigned int width)
{
unsigned precision = get_precision (x);
if (precision < bitpos + width)
precision = bitpos + width;
generic_wide_int <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, wi::int_traits <T>::host_dependent_precision> > xi (x, precision);
if (width == 0)
return 0;
unsigned int start = bitpos / 64;
unsigned int shift = bitpos % 64;
unsigned long res = xi.elt (start);
res >>= shift;
if (shift + width > 64)
{
unsigned long upper = xi.elt (start + 1);
res |= upper << (-shift % 64);
}
return zext_hwi (res, width);
}
template <typename T>
inline unsigned int
wi::min_precision (const T &x, signop sgn)
{
if (sgn == SIGNED)
return get_precision (x) - clrsb (x);
else
return get_precision (x) - clz (x);
}
# 3248 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator < (const T1 &x, const T2 &y) { return wi::lts_p (x, y); }
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator <= (const T1 &x, const T2 &y) { return wi::les_p (x, y); }
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator > (const T1 &x, const T2 &y) { return wi::gts_p (x, y); }
template <typename T1, typename T2> inline typename wi::binary_traits <T1, T2>::signed_predicate_result operator >= (const T1 &x, const T2 &y) { return wi::ges_p (x, y); }
# 3287 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int.h"
template<typename T> typename wi::binary_traits <generic_wide_int<T>, generic_wide_int<T> >::result_type operator ~ (const generic_wide_int<T> &x) { return wi::bit_not (x); }
template<typename T> typename wi::binary_traits <generic_wide_int<T>, generic_wide_int<T> >::result_type operator - (const generic_wide_int<T> &x) { return wi::neg (x); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::predicate_result operator == (const T1 &x, const T2 &y) { return wi::eq_p (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::predicate_result operator != (const T1 &x, const T2 &y) { return wi::ne_p (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator & (const T1 &x, const T2 &y) { return wi::bit_and (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator | (const T1 &x, const T2 &y) { return wi::bit_or (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator ^ (const T1 &x, const T2 &y) { return wi::bit_xor (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator + (const T1 &x, const T2 &y) { return wi::add (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator - (const T1 &x, const T2 &y) { return wi::sub (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T2>::operator_result operator * (const T1 &x, const T2 &y) { return wi::mul (x, y); }
template<typename T1, typename T2> typename wi::binary_traits <T1, T1>::operator_result operator << (const T1 &x, const T2 &y) { return wi::lshift (x, y); }
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
operator >> (const T1 &x, const T2 &y)
{
return wi::arshift (x, y);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
operator / (const T1 &x, const T2 &y)
{
return wi::sdiv_trunc (x, y);
}
template <typename T1, typename T2>
inline typename wi::binary_traits <T1, T2>::signed_shift_result_type
operator % (const T1 &x, const T2 &y)
{
return wi::smod_trunc (x, y);
}
template<typename T>
void
gt_ggc_mx (generic_wide_int <T> *)
{
}
template<typename T>
void
gt_pch_nx (generic_wide_int <T> *)
{
}
template<typename T>
void
gt_pch_nx (generic_wide_int <T> *, void (*) (void *, void *), void *)
{
}
template<int N>
void
gt_ggc_mx (trailing_wide_ints <N> *)
{
}
template<int N>
void
gt_pch_nx (trailing_wide_ints <N> *)
{
}
template<int N>
void
gt_pch_nx (trailing_wide_ints <N> *, void (*) (void *, void *), void *)
{
}
namespace wi
{
struct never_used1 {};
struct never_used2 {};
wide_int min_value (unsigned int, signop);
wide_int min_value (never_used1 *);
wide_int min_value (never_used2 *);
wide_int max_value (unsigned int, signop);
wide_int max_value (never_used1 *);
wide_int max_value (never_used2 *);
wide_int from_buffer (const unsigned char *, unsigned int);
void to_mpz (const wide_int_ref &, mpz_t, signop);
wide_int mask (unsigned int, bool, unsigned int);
wide_int shifted_mask (unsigned int, unsigned int, bool, unsigned int);
wide_int set_bit_in_zero (unsigned int, unsigned int);
wide_int insert (const wide_int &x, const wide_int &y, unsigned int,
unsigned int);
wide_int round_down_for_mask (const wide_int &, const wide_int &);
wide_int round_up_for_mask (const wide_int &, const wide_int &);
wide_int mod_inv (const wide_int &a, const wide_int &b);
template <typename T>
T mask (unsigned int, bool);
template <typename T>
T shifted_mask (unsigned int, unsigned int, bool);
template <typename T>
T set_bit_in_zero (unsigned int);
unsigned int mask (long *, unsigned int, bool, unsigned int);
unsigned int shifted_mask (long *, unsigned int, unsigned int,
bool, unsigned int);
unsigned int from_array (long *, const long *,
unsigned int, unsigned int, bool);
}
inline wide_int
wi::mask (unsigned int width, bool negate_p, unsigned int precision)
{
wide_int result = wide_int::create (precision);
result.set_len (mask (result.write_val (), width, negate_p, precision));
return result;
}
inline wide_int
wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p,
unsigned int precision)
{
wide_int result = wide_int::create (precision);
result.set_len (shifted_mask (result.write_val (), start, width, negate_p,
precision));
return result;
}
inline wide_int
wi::set_bit_in_zero (unsigned int bit, unsigned int precision)
{
return shifted_mask (bit, 1, false, precision);
}
template <typename T>
inline T
wi::mask (unsigned int width, bool negate_p)
{
static_assert ((wi::int_traits<T>::precision), "wi::int_traits<T>::precision");
T result;
result.set_len (mask (result.write_val (), width, negate_p,
wi::int_traits <T>::precision));
return result;
}
template <typename T>
inline T
wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p)
{
static_assert ((wi::int_traits<T>::precision), "wi::int_traits<T>::precision");
T result;
result.set_len (shifted_mask (result.write_val (), start, width,
negate_p,
wi::int_traits <T>::precision));
return result;
}
template <typename T>
inline T
wi::set_bit_in_zero (unsigned int bit)
{
return shifted_mask <T> (bit, 1, false);
}
static inline void
wi::accumulate_overflow (wi::overflow_type &overflow,
wi::overflow_type suboverflow)
{
if (!suboverflow)
return;
if (!overflow)
overflow = suboverflow;
else if (overflow != suboverflow)
overflow = wi::OVF_UNKNOWN;
}
# 452 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int-print.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int-print.h"
extern void print_dec (const wide_int_ref &wi, char *buf, signop sgn);
extern void print_dec (const wide_int_ref &wi, FILE *file, signop sgn);
extern void print_decs (const wide_int_ref &wi, char *buf);
extern void print_decs (const wide_int_ref &wi, FILE *file);
extern void print_decu (const wide_int_ref &wi, char *buf);
extern void print_decu (const wide_int_ref &wi, FILE *file);
extern void print_hex (const wide_int_ref &wi, char *buf);
extern void print_hex (const wide_int_ref &wi, FILE *file);
# 453 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 466 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h" 1
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename T> struct poly_int_pod;
template<unsigned int N, typename T> class poly_int;
# 62 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T, wi::precision_type = wi::int_traits<T>::precision_type>
struct poly_coeff_traits;
template<typename T>
struct poly_coeff_traits<T, wi::FLEXIBLE_PRECISION>
{
typedef T result;
typedef T int_type;
static const int signedness = (T (0) >= T (-1));
static const int precision = sizeof (T) * 8;
static const T max_value = (signedness
? ((T (1) << (precision - 2))
+ ((T (1) << (precision - 2)) - 1))
: T (-1));
static const int rank = sizeof (T) * 2 + !signedness;
};
template<typename T>
struct poly_coeff_traits<T, wi::VAR_PRECISION>
{
typedef T result;
typedef int int_type;
static const int signedness = -1;
static const int precision = (((160 + 64) / 64) * 64);
static const int rank = 0x7fffffff;
};
template<typename T>
struct poly_coeff_traits<T, wi::CONST_PRECISION>
{
typedef typename wi::binary_traits <T, T>::result_type result;
typedef int int_type;
static const int signedness = 1;
static const int precision = wi::int_traits<T>::precision;
static const int rank = precision * 2 / 8;
};
template<typename T1, typename T2>
struct poly_coeff_pair_traits
{
# 118 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
static const bool lossless_p = (poly_coeff_traits<T1>::signedness
== poly_coeff_traits<T2>::signedness
? (poly_coeff_traits<T1>::precision
>= poly_coeff_traits<T2>::precision)
: (poly_coeff_traits<T1>::signedness == 1
&& poly_coeff_traits<T2>::signedness == 0
&& (poly_coeff_traits<T1>::precision
> poly_coeff_traits<T2>::precision)));
static const int result_kind
= ((poly_coeff_traits<T1>::rank <= poly_coeff_traits<long>::rank
&& poly_coeff_traits<T2>::rank <= poly_coeff_traits<long>::rank)
? 0
: (poly_coeff_traits<T1>::rank <= poly_coeff_traits<unsigned long>::rank
&& poly_coeff_traits<T2>::rank <= poly_coeff_traits<unsigned long>::rank)
? 1 : 2);
};
template<typename T1, typename T2, typename T3,
bool lossless_p = poly_coeff_pair_traits<T1, T2>::lossless_p>
struct if_lossless;
template<typename T1, typename T2, typename T3>
struct if_lossless<T1, T2, T3, true>
{
typedef T3 type;
};
# 166 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T>
struct poly_int_traits
{
static const bool is_poly = false;
static const unsigned int num_coeffs = 1;
typedef T coeff_type;
typedef typename poly_coeff_traits<T>::int_type int_type;
};
template<unsigned int N, typename C>
struct poly_int_traits<poly_int_pod<N, C> >
{
static const bool is_poly = true;
static const unsigned int num_coeffs = N;
typedef C coeff_type;
typedef typename poly_coeff_traits<C>::int_type int_type;
};
template<unsigned int N, typename C>
struct poly_int_traits<poly_int<N, C> > : poly_int_traits<poly_int_pod<N, C> >
{
};
template<typename T1, typename T2 = T1,
bool is_poly = poly_int_traits<T1>::is_poly>
struct if_nonpoly {};
template<typename T1, typename T2>
struct if_nonpoly<T1, T2, false>
{
typedef T2 type;
};
template<typename T1, typename T2, typename T3,
bool is_poly1 = poly_int_traits<T1>::is_poly,
bool is_poly2 = poly_int_traits<T2>::is_poly>
struct if_nonpoly2 {};
template<typename T1, typename T2, typename T3>
struct if_nonpoly2<T1, T2, T3, false, false>
{
typedef T3 type;
};
template<typename T1, typename T2 = T1,
bool is_poly = poly_int_traits<T1>::is_poly>
struct if_poly {};
template<typename T1, typename T2>
struct if_poly<T1, T2, true>
{
typedef T2 type;
};
# 234 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T1, typename T2 = T1,
int result_kind = poly_coeff_pair_traits<T1, T2>::result_kind>
struct poly_result;
template<typename T1, typename T2>
struct poly_result<T1, T2, 0>
{
typedef long type;
typedef type cast;
};
template<typename T1, typename T2>
struct poly_result<T1, T2, 1>
{
typedef unsigned long type;
typedef type cast;
};
template<typename T1, typename T2>
struct poly_result<T1, T2, 2>
{
typedef typename wi::binary_traits <T1, T2>::result_type type;
typedef const T1 &cast;
};
# 337 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename C>
struct poly_int_pod
{
public:
template<typename Ca>
poly_int_pod &operator = (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator = (const Ca &);
template<typename Ca>
poly_int_pod &operator += (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator += (const Ca &);
template<typename Ca>
poly_int_pod &operator -= (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator -= (const Ca &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int_pod>::type &operator *= (const Ca &);
poly_int_pod &operator <<= (unsigned int);
bool is_constant () const;
template<typename T>
typename if_lossless<T, C, bool>::type is_constant (T *) const;
C to_constant () const;
template<typename Ca>
static poly_int<N, C> from (const poly_int_pod<N, Ca> &, unsigned int,
signop);
template<typename Ca>
static poly_int<N, C> from (const poly_int_pod<N, Ca> &, signop);
bool to_shwi (poly_int_pod<N, long> *) const;
bool to_uhwi (poly_int_pod<N, unsigned long> *) const;
poly_int<N, long> force_shwi () const;
poly_int<N, unsigned long> force_uhwi () const;
C coeffs[N];
};
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator = (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator = (const Ca &a)
{
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = a) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (a)));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator += (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] += a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator += (const Ca &a)
{
this->coeffs[0] += a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator -= (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] -= a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator -= (const Ca &a)
{
this->coeffs[0] -= a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int_pod<N, C> >::type &
poly_int_pod<N, C>::operator *= (const Ca &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] *= a;
return *this;
}
template<unsigned int N, typename C>
inline poly_int_pod<N, C>&
poly_int_pod<N, C>::operator <<= (unsigned int a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] <<= a;
return *this;
}
template<unsigned int N, typename C>
inline bool
poly_int_pod<N, C>::is_constant () const
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (this->coeffs[i] != 0)
return false;
return true;
}
template<unsigned int N, typename C>
template<typename T>
inline typename if_lossless<T, C, bool>::type
poly_int_pod<N, C>::is_constant (T *const_value) const
{
if (is_constant ())
{
*const_value = this->coeffs[0];
return true;
}
return false;
}
template<unsigned int N, typename C>
inline C
poly_int_pod<N, C>::to_constant () const
{
((void)(!(is_constant ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 504, __FUNCTION__), 0 : 0));
return this->coeffs[0];
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>
poly_int_pod<N, C>::from (const poly_int_pod<N, Ca> &a,
unsigned int bitsize, signop sgn)
{
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = C::from (a.coeffs[i], bitsize, sgn)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (C::from (a.coeffs[i], bitsize, sgn))));
return r;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>
poly_int_pod<N, C>::from (const poly_int_pod<N, Ca> &a, signop sgn)
{
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = C::from (a.coeffs[i], sgn)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (C::from (a.coeffs[i], sgn))));
return r;
}
template<unsigned int N, typename C>
inline bool
poly_int_pod<N, C>::to_shwi (poly_int_pod<N, long> *r) const
{
for (unsigned int i = 0; i < N; i++)
if (!wi::fits_shwi_p (this->coeffs[i]))
return false;
for (unsigned int i = 0; i < N; i++)
r->coeffs[i] = this->coeffs[i].to_shwi ();
return true;
}
template<unsigned int N, typename C>
inline bool
poly_int_pod<N, C>::to_uhwi (poly_int_pod<N, unsigned long> *r) const
{
for (unsigned int i = 0; i < N; i++)
if (!wi::fits_uhwi_p (this->coeffs[i]))
return false;
for (unsigned int i = 0; i < N; i++)
r->coeffs[i] = this->coeffs[i].to_uhwi ();
return true;
}
template<unsigned int N, typename C>
inline poly_int<N, long>
poly_int_pod<N, C>::force_shwi () const
{
poly_int_pod<N, long> r;
for (unsigned int i = 0; i < N; i++)
r.coeffs[i] = this->coeffs[i].to_shwi ();
return r;
}
template<unsigned int N, typename C>
inline poly_int<N, unsigned long>
poly_int_pod<N, C>::force_uhwi () const
{
poly_int_pod<N, unsigned long> r;
for (unsigned int i = 0; i < N; i++)
r.coeffs[i] = this->coeffs[i].to_uhwi ();
return r;
}
# 611 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename C>
class poly_int : public poly_int_pod<N, C>
{
public:
poly_int () {}
template<typename Ca>
poly_int (const poly_int<N, Ca> &);
template<typename Ca>
poly_int (const poly_int_pod<N, Ca> &);
template<typename C0>
poly_int (const C0 &);
template<typename C0, typename C1>
poly_int (const C0 &, const C1 &);
template<typename Ca>
poly_int &operator = (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator = (const Ca &);
template<typename Ca>
poly_int &operator += (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator += (const Ca &);
template<typename Ca>
poly_int &operator -= (const poly_int_pod<N, Ca> &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator -= (const Ca &);
template<typename Ca>
typename if_nonpoly<Ca, poly_int>::type &operator *= (const Ca &);
poly_int &operator <<= (unsigned int);
};
template<unsigned int N, typename C>
template<typename Ca>
inline
poly_int<N, C>::poly_int (const poly_int<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
}
template<unsigned int N, typename C>
template<typename Ca>
inline
poly_int<N, C>::poly_int (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = a.coeffs[i]) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (a.coeffs[i])));
}
template<unsigned int N, typename C>
template<typename C0>
inline
poly_int<N, C>::poly_int (const C0 &c0)
{
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = c0) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (c0)));
for (unsigned int i = 1; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
}
template<unsigned int N, typename C>
template<typename C0, typename C1>
inline
poly_int<N, C>::poly_int (const C0 &c0, const C1 &c1)
{
static_assert ((N >= 2), "N >= 2");
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[0] = c0) : (void) ((*this).coeffs[0].~C (), new (&(*this).coeffs[0]) C (c0)));
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[1] = c1) : (void) ((*this).coeffs[1].~C (), new (&(*this).coeffs[1]) C (c1)));
for (unsigned int i = 2; i < N; i++)
((void) (&(*this).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((*this).coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0])) : (void) ((*this).coeffs[i].~C (), new (&(*this).coeffs[i]) C (wi::ints_for<C>::zero (this->coeffs[0]))));
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>&
poly_int<N, C>::operator = (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] = a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator = (const Ca &a)
{
this->coeffs[0] = a;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
this->coeffs[i] = wi::ints_for<C>::zero (this->coeffs[0]);
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>&
poly_int<N, C>::operator += (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] += a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator += (const Ca &a)
{
this->coeffs[0] += a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline poly_int<N, C>&
poly_int<N, C>::operator -= (const poly_int_pod<N, Ca> &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] -= a.coeffs[i];
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator -= (const Ca &a)
{
this->coeffs[0] -= a;
return *this;
}
template<unsigned int N, typename C>
template<typename Ca>
inline typename if_nonpoly<Ca, poly_int<N, C> >::type &
poly_int<N, C>::operator *= (const Ca &a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] *= a;
return *this;
}
template<unsigned int N, typename C>
inline poly_int<N, C>&
poly_int<N, C>::operator <<= (unsigned int a)
{
for (unsigned int i = 0; i < N; i++)
this->coeffs[i] <<= a;
return *this;
}
template<typename Ca, typename Cb, typename Cc>
inline typename if_nonpoly<Ca, bool>::type
coeffs_in_range_p (const Ca &a, const Cb &b, const Cc &c)
{
return a >= b && a <= c;
}
template<unsigned int N, typename Ca, typename Cb, typename Cc>
inline typename if_nonpoly<Ca, bool>::type
coeffs_in_range_p (const poly_int_pod<N, Ca> &a, const Cb &b, const Cc &c)
{
for (unsigned int i = 0; i < N; i++)
if (a.coeffs[i] < b || a.coeffs[i] > c)
return false;
return true;
}
namespace wi {
template<unsigned int N>
inline poly_int<N, hwi_with_prec>
shwi (const poly_int_pod<N, long> &a, unsigned int precision)
{
poly_int<N, hwi_with_prec> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (hwi_with_prec *) 0), wi::int_traits<hwi_with_prec>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::shwi (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~hwi_with_prec (), new (&(r).coeffs[i]) hwi_with_prec (wi::shwi (a.coeffs[i], precision))));
return r;
}
template<unsigned int N>
inline poly_int<N, hwi_with_prec>
uhwi (const poly_int_pod<N, unsigned long> &a, unsigned int precision)
{
poly_int<N, hwi_with_prec> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (hwi_with_prec *) 0), wi::int_traits<hwi_with_prec>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::uhwi (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~hwi_with_prec (), new (&(r).coeffs[i]) hwi_with_prec (wi::uhwi (a.coeffs[i], precision))));
return r;
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
sext (const poly_int_pod<N, Ca> &a, unsigned int precision)
{
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sext (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sext (a.coeffs[i], precision))));
return r;
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
zext (const poly_int_pod<N, Ca> &a, unsigned int precision)
{
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::zext (a.coeffs[i], precision)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::zext (a.coeffs[i], precision))));
return r;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
operator + (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) + b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) + b.coeffs[i])));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
operator + (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = NCa (a.coeffs[0]) + b) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (NCa (a.coeffs[0]) + b)));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
operator + (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = a + NCb (b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (a + NCb (b.coeffs[0]))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCb (b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCb (b.coeffs[i]))));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], b.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a.coeffs[0], b)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a.coeffs[0], b))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], wi::ints_for<Cb>::zero (b))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], wi::ints_for<Cb>::zero (b)))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a, b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a, b.coeffs[0]))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (wi::ints_for<Ca>::zero (a), b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (wi::ints_for<Ca>::zero (a), b.coeffs[i]))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
add (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
signop sgn, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::add (a.coeffs[0], b.coeffs[0], sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::add (a.coeffs[0], b.coeffs[0], sgn, overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::add (a.coeffs[i], b.coeffs[i], sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::add (a.coeffs[i], b.coeffs[i], sgn, &suboverflow))))
;
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
operator - (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) - b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) - b.coeffs[i])));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
operator - (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = NCa (a.coeffs[0]) - b) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (NCa (a.coeffs[0]) - b)));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
operator - (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = a - NCb (b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (a - NCb (b.coeffs[0]))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = -NCb (b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (-NCb (b.coeffs[i]))));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], b.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a.coeffs[0], b)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a.coeffs[0], b))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], wi::ints_for<Cb>::zero (b))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], wi::ints_for<Cb>::zero (b)))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a, b.coeffs[0])) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a, b.coeffs[0]))));
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (wi::ints_for<Ca>::zero (a), b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (wi::ints_for<Ca>::zero (a), b.coeffs[i]))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
sub (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
signop sgn, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::sub (a.coeffs[0], b.coeffs[0], sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::sub (a.coeffs[0], b.coeffs[0], sgn, overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::sub (a.coeffs[i], b.coeffs[i], sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::sub (a.coeffs[i], b.coeffs[i], sgn, &suboverflow))))
;
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
operator - (const poly_int_pod<N, Ca> &a)
{
typedef typename poly_result<Ca, Ca>::cast NCa;
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = -NCa (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (-NCa (a.coeffs[i]))));
return r;
}
namespace wi {
template<unsigned int N, typename Ca>
inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
neg (const poly_int_pod<N, Ca> &a)
{
typedef typename wi::binary_traits <Ca, Ca>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::neg (a.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::neg (a.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
neg (const poly_int_pod<N, Ca> &a, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Ca>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::neg (a.coeffs[0], overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::neg (a.coeffs[0], overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::neg (a.coeffs[i], &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::neg (a.coeffs[i], &suboverflow))));
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
operator ~ (const poly_int_pod<N, Ca> &a)
{
if (N >= 2)
return -1 - a;
return ~a.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
operator * (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) * b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) * b)));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
operator * (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a) * b.coeffs[i]) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a) * b.coeffs[i])));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
mul (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a.coeffs[i], b)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a.coeffs[i], b))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
mul (const Ca &a, const poly_int_pod<N, Cb> &b)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a, b.coeffs[i])) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a, b.coeffs[i]))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Cb>::result_type>
mul (const poly_int_pod<N, Ca> &a, const Cb &b,
signop sgn, wi::overflow_type *overflow)
{
typedef typename wi::binary_traits <Ca, Cb>::result_type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = wi::mul (a.coeffs[0], b, sgn, overflow)) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (wi::mul (a.coeffs[0], b, sgn, overflow))));
for (unsigned int i = 1; i < N; i++)
{
wi::overflow_type suboverflow;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::mul (a.coeffs[i], b, sgn, &suboverflow)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::mul (a.coeffs[i], b, sgn, &suboverflow))));
wi::accumulate_overflow (*overflow, suboverflow);
}
return r;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Ca>::type>
operator << (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Ca>::cast NCa;
typedef typename poly_result<Ca, Ca>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = NCa (a.coeffs[i]) << b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (NCa (a.coeffs[i]) << b)));
return r;
}
namespace wi {
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename wi::binary_traits <Ca, Ca>::result_type>
lshift (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename wi::binary_traits <Ca, Ca>::result_type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = wi::lshift (a.coeffs[i], b)) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (wi::lshift (a.coeffs[i], b))));
return r;
}
}
template<typename Ca, typename Cb>
inline bool
maybe_eq_2 (const Ca &a0, const Ca &a1, const Cb &b0, const Cb &b1)
{
if (a1 != b1)
return (a1 < b1
? b0 <= a0 && (a0 - b0) % (b1 - a1) == 0
: b0 >= a0 && (b0 - a0) % (a1 - b1) == 0);
return a0 == b0;
}
template<typename Ca, typename Cb>
inline bool
maybe_eq_2 (const Ca &a0, const Ca &a1, const Cb &b)
{
if (a1 != 0)
return (a1 < 0
? b <= a0 && (a0 - b) % a1 == 0
: b >= a0 && (b - a0) % a1 == 0);
return a0 == b;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_eq (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
static_assert ((N <= 2), "N <= 2");
if (N == 2)
return maybe_eq_2 (a.coeffs[0], a.coeffs[1], b.coeffs[0], b.coeffs[1]);
return a.coeffs[0] == b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_eq (const poly_int_pod<N, Ca> &a, const Cb &b)
{
static_assert ((N <= 2), "N <= 2");
if (N == 2)
return maybe_eq_2 (a.coeffs[0], a.coeffs[1], b);
return a.coeffs[0] == b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_eq (const Ca &a, const poly_int_pod<N, Cb> &b)
{
static_assert ((N <= 2), "N <= 2");
if (N == 2)
return maybe_eq_2 (b.coeffs[0], b.coeffs[1], a);
return a == b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_eq (const Ca &a, const Cb &b)
{
return a == b;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_ne (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] != b.coeffs[i])
return true;
return a.coeffs[0] != b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_ne (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] != 0)
return true;
return a.coeffs[0] != b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_ne (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (b.coeffs[i] != 0)
return true;
return a != b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_ne (const Ca &a, const Cb &b)
{
return a != b;
}
# 1312 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_le (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < b.coeffs[i])
return true;
return a.coeffs[0] <= b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_le (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < 0)
return true;
return a.coeffs[0] <= b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_le (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (b.coeffs[i] > 0)
return true;
return a <= b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_le (const Ca &a, const Cb &b)
{
return a <= b;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
maybe_lt (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < b.coeffs[i])
return true;
return a.coeffs[0] < b.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
maybe_lt (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (a.coeffs[i] < 0)
return true;
return a.coeffs[0] < b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
maybe_lt (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if (b.coeffs[i] > 0)
return true;
return a < b.coeffs[0];
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
maybe_lt (const Ca &a, const Cb &b)
{
return a < b;
}
# 1414 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T1, typename T2>
inline bool
ordered_p (const T1 &a, const T2 &b)
{
return ((poly_int_traits<T1>::num_coeffs == 1
&& poly_int_traits<T2>::num_coeffs == 1)
|| (!maybe_lt (b, a))
|| (!maybe_lt (a, b)));
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
ordered_min (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return a;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1439, __FUNCTION__), 0 : 0));
return b;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
ordered_min (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return a;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1453, __FUNCTION__), 0 : 0));
return b;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
ordered_min (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (b, a)))
return a;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1467, __FUNCTION__), 0 : 0));
return b;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
ordered_max (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return b;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1487, __FUNCTION__), 0 : 0));
return a;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
ordered_max (const Ca &a, const poly_int_pod<N, Cb> &b)
{
if ((!maybe_lt (b, a)))
return b;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1501, __FUNCTION__), 0 : 0));
return a;
}
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
ordered_max (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (b, a)))
return b;
else
{
if (N > 1)
((void)(!((!maybe_lt (a, b))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1515, __FUNCTION__), 0 : 0));
return a;
}
}
template<unsigned int N, typename Ca>
inline Ca
constant_lower_bound (const poly_int_pod<N, Ca> &a)
{
((void)(!((!maybe_lt (a, typename poly_int_traits<Ca>::int_type (0)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1527, __FUNCTION__), 0 : 0));
return a.coeffs[0];
}
template<unsigned int N, typename Ca, typename Cb>
inline typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type
constant_lower_bound_with_limit (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (a, b)))
return a.coeffs[0];
return b;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type
constant_upper_bound_with_limit (const poly_int_pod<N, Ca> &a, const Cb &b)
{
if ((!maybe_lt (b, a)))
return a.coeffs[0];
return b;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
lower_bound (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((NCa (a.coeffs[0])) < (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b)))) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (((NCa (a.coeffs[0])) < (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b))))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) < (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0)))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) < (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0))))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
lower_bound (const Ca &a, const poly_int_pod<N, Cb> &b)
{
return lower_bound (b, a);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
lower_bound (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) < (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i])))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) < (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i]))))));
return r;
}
template<typename Ca, typename Cb>
inline typename poly_result<typename if_nonpoly<Ca>::type, typename if_nonpoly<Cb>::type>::type
lower_bound (const Ca &a, const Cb &b)
{
return a < b ? a : b;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
upper_bound (const poly_int_pod<N, Ca> &a, const Cb &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((NCa (a.coeffs[0])) > (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b)))) : (void) ((r).coeffs[0].~C (), new (&(r).coeffs[0]) C (((NCa (a.coeffs[0])) > (NCb (b)) ? (NCa (a.coeffs[0])) : (NCb (b))))));
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) > (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0)))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) > (ICb (0)) ? (NCa (a.coeffs[i])) : (ICb (0))))));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
upper_bound (const Ca &a, const poly_int_pod<N, Cb> &b)
{
return upper_bound (b, a);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
upper_bound (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<Ca, Cb>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = ((NCa (a.coeffs[i])) > (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i])))) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (((NCa (a.coeffs[i])) > (NCb (b.coeffs[i])) ? (NCa (a.coeffs[i])) : (NCb (b.coeffs[i]))))));
return r;
}
template<unsigned int N, typename Ca>
inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
coeff_gcd (const poly_int_pod<N, Ca> &a)
{
unsigned int i;
for (i = N - 1; i > 0; --i)
if (a.coeffs[i] != 0)
break;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type C;
C r = a.coeffs[i];
for (unsigned int j = 0; j < i; ++j)
if (a.coeffs[j] != 0)
r = gcd (r, C (a.coeffs[j]));
return r;
}
template<unsigned int N, typename Ca, typename Cb>
poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
common_multiple (const poly_int_pod<N, Ca> &a, Cb b)
{
typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type xgcd = coeff_gcd (a);
return a * (least_common_multiple (xgcd, b) / xgcd);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<typename if_nonpoly<Ca>::type, Cb>::type>
common_multiple (const Ca &a, const poly_int_pod<N, Cb> &b)
{
return common_multiple (b, a);
}
# 1692 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
poly_int<N, typename poly_result<Ca, Cb>::type>
force_common_multiple (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b)
{
if (b.is_constant ())
return common_multiple (a, b.coeffs[0]);
if (a.is_constant ())
return common_multiple (a.coeffs[0], b);
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
typedef typename poly_int_traits<Ca>::int_type ICa;
for (unsigned int i = 1; i < N; ++i)
if (a.coeffs[i] != ICa (0))
{
C lcm = least_common_multiple (NCa (a.coeffs[i]), NCb (b.coeffs[i]));
C amul = lcm / a.coeffs[i];
C bmul = lcm / b.coeffs[i];
for (unsigned int j = 0; j < N; ++j)
((void)(!(a.coeffs[j] * amul == b.coeffs[j] * bmul) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1714, __FUNCTION__), 0 : 0));
return a * amul;
}
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1717, __FUNCTION__));
}
# 1731 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline int
compare_sizes_for_sort (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b)
{
for (unsigned int i = N; i-- > 0; )
if (a.coeffs[i] != b.coeffs[i])
return a.coeffs[i] < b.coeffs[i] ? -1 : 1;
return 0;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
can_align_p (const poly_int_pod<N, Ca> &value, Cb align)
{
for (unsigned int i = 1; i < N; i++)
if ((value.coeffs[i] & (align - 1)) != 0)
return false;
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
can_align_up (const poly_int_pod<N, Ca> &value, Cb align,
poly_int_pod<N, Ca> *aligned)
{
if (!can_align_p (value, align))
return false;
*aligned = value + (-value.coeffs[0] & (align - 1));
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
can_align_down (const poly_int_pod<N, Ca> &value, Cb align,
poly_int_pod<N, Ca> *aligned)
{
if (!can_align_p (value, align))
return false;
*aligned = value - (value.coeffs[0] & (align - 1));
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cc>
inline bool
known_equal_after_align_up (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cc align)
{
poly_int<N, Ca> aligned_a;
poly_int<N, Cb> aligned_b;
return (can_align_up (a, align, &aligned_a)
&& can_align_up (b, align, &aligned_b)
&& (!maybe_ne (aligned_a, aligned_b)));
}
template<unsigned int N, typename Ca, typename Cb, typename Cc>
inline bool
known_equal_after_align_down (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cc align)
{
poly_int<N, Ca> aligned_a;
poly_int<N, Cb> aligned_b;
return (can_align_down (a, align, &aligned_a)
&& can_align_down (b, align, &aligned_b)
&& (!maybe_ne (aligned_a, aligned_b)));
}
# 1823 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_up (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1827, __FUNCTION__), 0 : 0));
return value + (-value.coeffs[0] & (align - 1));
}
# 1838 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_down (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1842, __FUNCTION__), 0 : 0));
return value - (value.coeffs[0] & (align - 1));
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
aligned_lower_bound (const poly_int_pod<N, Ca> &value, Cb align)
{
poly_int<N, Ca> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = (value.coeffs[i] - (value.coeffs[i] & (align - 1)))) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca ((value.coeffs[i] - (value.coeffs[i] & (align - 1))))))
;
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
aligned_upper_bound (const poly_int_pod<N, Ca> &value, Cb align)
{
poly_int<N, Ca> r;
for (unsigned int i = 0; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = (value.coeffs[i] + (-value.coeffs[i] & (align - 1)))) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca ((value.coeffs[i] + (-value.coeffs[i] & (align - 1))))))
;
return r;
}
# 1886 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_down_and_div (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1890, __FUNCTION__), 0 : 0));
poly_int<N, Ca> r;
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((value.coeffs[0] - (value.coeffs[0] & (align - 1))) / align)) : (void) ((r).coeffs[0].~Ca (), new (&(r).coeffs[0]) Ca (((value.coeffs[0] - (value.coeffs[0] & (align - 1))) / align))))
;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = value.coeffs[i] / align) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca (value.coeffs[i] / align)));
return r;
}
# 1910 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, Ca>
force_align_up_and_div (const poly_int_pod<N, Ca> &value, Cb align)
{
((void)(!(can_align_p (value, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1914, __FUNCTION__), 0 : 0));
poly_int<N, Ca> r;
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[0] = ((value.coeffs[0] + (-value.coeffs[0] & (align - 1))) / align)) : (void) ((r).coeffs[0].~Ca (), new (&(r).coeffs[0]) Ca (((value.coeffs[0] + (-value.coeffs[0] & (align - 1))) / align))))
;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
((void) (&(r).coeffs[0] == (Ca *) 0), wi::int_traits<Ca>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = value.coeffs[i] / align) : (void) ((r).coeffs[i].~Ca (), new (&(r).coeffs[i]) Ca (value.coeffs[i] / align)));
return r;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline bool
known_misalignment (const poly_int_pod<N, Ca> &value, Cb align, Cm *misalign)
{
((void)(!(align != 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1934, __FUNCTION__), 0 : 0));
if (!can_align_p (value, align))
return false;
*misalign = value.coeffs[0] & (align - 1);
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
force_get_misalignment (const poly_int_pod<N, Ca> &a, Cb align)
{
((void)(!(can_align_p (a, align)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 1949, __FUNCTION__), 0 : 0));
return a.coeffs[0] & (align - 1);
}
template<unsigned int N, typename Ca>
inline typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type
known_alignment (const poly_int_pod<N, Ca> &a)
{
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type C;
C r = a.coeffs[0];
for (unsigned int i = 1; i < N; ++i)
r |= a.coeffs[i];
return r & -r;
}
template<unsigned int N, typename Ca, typename Cb, typename Cr>
inline typename if_nonpoly<Cb, bool>::type
can_ior_p (const poly_int_pod<N, Ca> &a, Cb b, Cr *result)
{
typedef typename poly_int_traits<Ca>::int_type int_type;
if (N >= 2)
for (unsigned int i = 1; i < N; i++)
if ((-(a.coeffs[i] & -a.coeffs[i]) & b) != int_type (0))
return false;
*result = a;
result->coeffs[0] |= b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Cb, bool>::type
constant_multiple_p (const poly_int_pod<N, Ca> &a, Cb b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
if (NCa (a.coeffs[0]) % NCb (b) != 0 || !a.is_constant ())
return false;
*multiple = NCa (a.coeffs[0]) / NCb (b);
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Ca, bool>::type
constant_multiple_p (Ca a, const poly_int_pod<N, Cb> &b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Ca>::int_type int_type;
if (NCa (a) % NCb (b.coeffs[0]) != 0
|| (a != int_type (0) && !b.is_constant ()))
return false;
*multiple = NCa (a) / NCb (b.coeffs[0]);
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline bool
constant_multiple_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Ca>::int_type ICa;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
if (NCa (a.coeffs[0]) % NCb (b.coeffs[0]) != 0)
return false;
C r = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
for (unsigned int i = 1; i < N; ++i)
if (b.coeffs[i] == ICb (0)
? a.coeffs[i] != ICa (0)
: (NCa (a.coeffs[i]) % NCb (b.coeffs[i]) != 0
|| NCa (a.coeffs[i]) / NCb (b.coeffs[i]) != r))
return false;
*multiple = r;
return true;
}
template<typename Ca, typename Cb>
inline typename if_nonpoly2<Ca, Cb, bool>::type
multiple_p (Ca a, Cb b)
{
return a % b == 0;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Cb, bool>::type
multiple_p (const poly_int_pod<N, Ca> &a, Cb b)
{
for (unsigned int i = 0; i < N; ++i)
if (a.coeffs[i] % b != 0)
return false;
return true;
}
template<unsigned int N, typename Ca, typename Cb>
inline typename if_nonpoly<Ca, bool>::type
multiple_p (Ca a, const poly_int_pod<N, Cb> &b)
{
typedef typename poly_int_traits<Ca>::int_type int_type;
return a % b.coeffs[0] == 0 && (a == int_type (0) || b.is_constant ());
}
template<unsigned int N, typename Ca, typename Cb>
inline bool
multiple_p (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (b.is_constant ())
return multiple_p (a, b.coeffs[0]);
typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Ca>::coeff_type>::type tmp;
return constant_multiple_p (a, b, &tmp);
}
template<typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly2<Ca, Cb, bool>::type
multiple_p (Ca a, Cb b, Cm *multiple)
{
if (a % b != 0)
return false;
*multiple = a / b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Cb, bool>::type
multiple_p (const poly_int_pod<N, Ca> &a, Cb b, poly_int_pod<N, Cm> *multiple)
{
if (!multiple_p (a, b))
return false;
for (unsigned int i = 0; i < N; ++i)
multiple->coeffs[i] = a.coeffs[i] / b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline typename if_nonpoly<Ca, bool>::type
multiple_p (Ca a, const poly_int_pod<N, Cb> &b, Cm *multiple)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
if (a % b.coeffs[0] != 0 || (NCa (a) != 0 && !b.is_constant ()))
return false;
*multiple = a / b.coeffs[0];
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cm>
inline bool
multiple_p (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b,
poly_int_pod<N, Cm> *multiple)
{
if (b.is_constant ())
return multiple_p (a, b.coeffs[0], multiple);
return constant_multiple_p (a, b, multiple);
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type>
exact_div (const poly_int_pod<N, Ca> &a, Cb b)
{
typedef typename poly_result<Ca, typename if_nonpoly<Cb>::type>::type C;
poly_int<N, C> r;
for (unsigned int i = 0; i < N; i++)
{
((void)(!(a.coeffs[i] % b == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 2162, __FUNCTION__), 0 : 0));
((void) (&(r).coeffs[0] == (C *) 0), wi::int_traits<C>::precision_type == wi::FLEXIBLE_PRECISION ? (void) ((r).coeffs[i] = a.coeffs[i] / b) : (void) ((r).coeffs[i].~C (), new (&(r).coeffs[i]) C (a.coeffs[i] / b)));
}
return r;
}
template<unsigned int N, typename Ca, typename Cb>
inline poly_int<N, typename poly_result<Ca, Cb>::type>
exact_div (const poly_int_pod<N, Ca> &a, const poly_int_pod<N, Cb> &b)
{
if (b.is_constant ())
return exact_div (a, b.coeffs[0]);
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
typedef typename poly_int_traits<Cb>::int_type int_type;
((void)(!(a.coeffs[0] % b.coeffs[0] == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 2182, __FUNCTION__), 0 : 0));
C r = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
for (unsigned int i = 1; i < N; ++i)
((void)(!(b.coeffs[i] == int_type (0) ? a.coeffs[i] == int_type (0) : (a.coeffs[i] % b.coeffs[i] == 0 && NCa (a.coeffs[i]) / NCb (b.coeffs[i]) == r)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h", 2185, __FUNCTION__), 0 : 0))
;
return r;
}
# 2201 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly2<Cb, Cq, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b, Cq *quotient)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
Cq q = NCa (a.coeffs[0]) / NCb (b);
if (!a.is_constant ())
return false;
*quotient = q;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly<Cq, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cq *quotient)
{
typedef typename poly_result<Ca, Cb>::cast NCa;
typedef typename poly_result<Cb, Ca>::cast NCb;
typedef typename poly_int_traits<Ca>::int_type ICa;
typedef typename poly_int_traits<Cb>::int_type ICb;
typedef typename poly_result<typename poly_int_traits<Ca>::coeff_type, typename poly_int_traits<Cb>::coeff_type>::type C;
C q = NCa (a.coeffs[0]) / NCb (b.coeffs[0]);
# 2277 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
bool rem_p = NCa (a.coeffs[0]) % NCb (b.coeffs[0]) != 0;
for (unsigned int i = 1; i < N; ++i)
{
if (b.coeffs[i] == ICb (0))
{
if (a.coeffs[i] != ICa (0))
return false;
}
else
{
if (q == 0)
{
if (a.coeffs[i] != ICa (0))
{
C neg_abs_a = (a.coeffs[i] < 0 ? a.coeffs[i] : -a.coeffs[i]);
C neg_abs_b = (b.coeffs[i] < 0 ? b.coeffs[i] : -b.coeffs[i]);
if (neg_abs_a < neg_abs_b)
return false;
rem_p = true;
}
}
else
{
if (NCa (a.coeffs[i]) / NCb (b.coeffs[i]) != q)
return false;
if (NCa (a.coeffs[i]) % NCb (b.coeffs[i]) != 0)
rem_p = true;
}
}
}
if (rem_p && (!ordered_p (a, ICa (0)) || !ordered_p (b, ICb (0))))
return false;
*quotient = q;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq, typename Cr>
inline typename if_nonpoly<Cq, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cq *quotient, Cr *remainder)
{
if (!can_div_trunc_p (a, b, quotient))
return false;
*remainder = a - *quotient * b;
return true;
}
# 2345 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly<Cb, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b,
poly_int_pod<N, Cq> *quotient)
{
for (unsigned int i = 1; i < N; ++i)
if (a.coeffs[i] % b != 0)
return false;
for (unsigned int i = 0; i < N; ++i)
quotient->coeffs[i] = a.coeffs[i] / b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq, typename Cr>
inline typename if_nonpoly<Cb, bool>::type
can_div_trunc_p (const poly_int_pod<N, Ca> &a, Cb b,
poly_int_pod<N, Cq> *quotient, Cr *remainder)
{
if (!can_div_trunc_p (a, b, quotient))
return false;
*remainder = a.coeffs[0] % b;
return true;
}
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline bool
can_div_trunc_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
poly_int_pod<N, Cq> *quotient)
{
if (b.is_constant ())
return can_div_trunc_p (a, b.coeffs[0], quotient);
if (!can_div_trunc_p (a, b, "ient->coeffs[0]))
return false;
for (unsigned int i = 1; i < N; ++i)
quotient->coeffs[i] = 0;
return true;
}
# 2401 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<unsigned int N, typename Ca, typename Cb, typename Cq>
inline typename if_nonpoly<Cq, bool>::type
can_div_away_from_zero_p (const poly_int_pod<N, Ca> &a,
const poly_int_pod<N, Cb> &b,
Cq *quotient)
{
if (!can_div_trunc_p (a, b, quotient))
return false;
if (maybe_ne (*quotient * b, a))
*quotient += (*quotient < 0 ? -1 : 1);
return true;
}
template<unsigned int N, typename C>
void
print_dec (const poly_int_pod<N, C> &value, FILE *file, signop sgn)
{
if (value.is_constant ())
print_dec (value.coeffs[0], file, sgn);
else
{
fprintf (file, "[");
for (unsigned int i = 0; i < N; ++i)
{
print_dec (value.coeffs[i], file, sgn);
fputc (i == N - 1 ? ']' : ',', file);
}
}
}
template<unsigned int N, typename C>
void
print_dec (const poly_int_pod<N, C> &value, FILE *file)
{
static_assert ((poly_coeff_traits<C>::signedness >= 0), "poly_coeff_traits<C>::signedness >= 0");
print_dec (value, file,
poly_coeff_traits<C>::signedness ? SIGNED : UNSIGNED);
}
template<unsigned int N, typename C>
void
print_hex (const poly_int_pod<N, C> &value, FILE *file)
{
if (value.is_constant ())
print_hex (value.coeffs[0], file);
else
{
fprintf (file, "[");
for (unsigned int i = 0; i < N; ++i)
{
print_hex (value.coeffs[i], file);
fputc (i == N - 1 ? ']' : ',', file);
}
}
}
# 2482 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
template<typename T1, typename T2,
typename Res = typename poly_result<typename poly_int_traits<typename poly_result<typename poly_int_traits<T1>::coeff_type, typename poly_int_traits<T2>::coeff_type>::type>::coeff_type, typename poly_int_traits<unsigned long>::coeff_type>::type
>
struct poly_span_traits
{
template<typename T>
static const T &cast (const T &x) { return x; }
};
template<typename T1, typename T2>
struct poly_span_traits<T1, T2, unsigned long>
{
template<typename T>
static typename if_nonpoly<T, unsigned long>::type
cast (const T &x) { return x; }
template<unsigned int N, typename T>
static poly_int<N, unsigned long>
cast (const poly_int_pod<N, T> &x) { return x; }
};
template<typename T>
inline bool
known_size_p (const T &a)
{
return maybe_ne (a, typename poly_int_traits<T>::int_type (-1));
}
template<typename T1, typename T2, typename T3>
inline bool
maybe_in_range_p (const T1 &val, const T2 &pos, const T3 &size)
{
typedef poly_span_traits<T1, T2> start_span;
typedef poly_span_traits<T3, T3> size_span;
if ((!maybe_le (pos, val)))
return false;
if (!known_size_p (size))
return true;
if ((poly_int_traits<T1>::num_coeffs > 1
|| poly_int_traits<T2>::num_coeffs > 1)
&& maybe_lt (val, pos))
return true;
return maybe_lt (start_span::cast (val) - start_span::cast (pos),
size_span::cast (size));
}
template<typename T1, typename T2, typename T3>
inline bool
known_in_range_p (const T1 &val, const T2 &pos, const T3 &size)
{
typedef poly_span_traits<T1, T2> start_span;
typedef poly_span_traits<T3, T3> size_span;
return (known_size_p (size)
&& (!maybe_lt (val, pos))
&& (!maybe_le (size_span::cast (size), start_span::cast (val) - start_span::cast (pos)))
);
}
template<typename T1, typename T2, typename T3, typename T4>
inline bool
ranges_maybe_overlap_p (const T1 &pos1, const T2 &size1,
const T3 &pos2, const T4 &size2)
{
if (maybe_in_range_p (pos2, pos1, size1))
return maybe_ne (size2, typename poly_int_traits<T4>::int_type (0));
if (maybe_in_range_p (pos1, pos2, size2))
return maybe_ne (size1, typename poly_int_traits<T2>::int_type (0));
return false;
}
template<typename T1, typename T2, typename T3, typename T4>
inline bool
ranges_known_overlap_p (const T1 &pos1, const T2 &size1,
const T3 &pos2, const T4 &size2)
{
typedef poly_span_traits<T1, T3> start_span;
typedef poly_span_traits<T2, T2> size1_span;
typedef poly_span_traits<T4, T4> size2_span;
# 2593 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int.h"
return (known_size_p (size1)
&& known_size_p (size2)
&& (!maybe_le (size1_span::cast (size1), start_span::cast (pos2) - start_span::cast (lower_bound (pos1, pos2))))
&& (!maybe_le (size2_span::cast (size2), start_span::cast (pos1) - start_span::cast (lower_bound (pos1, pos2))))
);
}
template<typename T1, typename T2, typename T3, typename T4>
inline bool
known_subrange_p (const T1 &pos1, const T2 &size1,
const T3 &pos2, const T4 &size2)
{
typedef typename poly_int_traits<T2>::coeff_type C2;
typedef poly_span_traits<T1, T3> start_span;
typedef poly_span_traits<T2, T4> size_span;
return ((!maybe_le (size1, typename poly_int_traits<T2>::int_type (0)))
&& (poly_coeff_traits<C2>::signedness > 0
|| known_size_p (size1))
&& known_size_p (size2)
&& (!maybe_lt (pos1, pos2))
&& (!maybe_lt (size2, size1))
&& (!maybe_lt (size_span::cast (size2) - size_span::cast (size1), start_span::cast (pos1) - start_span::cast (pos2)))
);
}
template<typename T>
inline typename if_nonpoly<T, bool>::type
endpoint_representable_p (const T &pos, const T &size)
{
return (!known_size_p (size)
|| pos <= poly_coeff_traits<T>::max_value - size);
}
template<unsigned int N, typename C>
inline bool
endpoint_representable_p (const poly_int_pod<N, C> &pos,
const poly_int_pod<N, C> &size)
{
if (known_size_p (size))
for (unsigned int i = 0; i < N; ++i)
if (pos.coeffs[i] > poly_coeff_traits<C>::max_value - size.coeffs[i])
return false;
return true;
}
template<unsigned int N, typename C>
void
gt_ggc_mx (poly_int_pod<N, C> *)
{
}
template<unsigned int N, typename C>
void
gt_pch_nx (poly_int_pod<N, C> *)
{
}
template<unsigned int N, typename C>
void
gt_pch_nx (poly_int_pod<N, C> *, void (*) (void *, void *), void *)
{
}
# 467 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int-types.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/poly-int-types.h"
typedef poly_int_pod<1, unsigned short> poly_uint16_pod;
typedef poly_int_pod<1, long> poly_int64_pod;
typedef poly_int_pod<1,
unsigned long> poly_uint64_pod;
typedef poly_int_pod<1, offset_int> poly_offset_int_pod;
typedef poly_int_pod<1, wide_int> poly_wide_int_pod;
typedef poly_int_pod<1, widest_int> poly_widest_int_pod;
typedef poly_int<1, unsigned short> poly_uint16;
typedef poly_int<1, long> poly_int64;
typedef poly_int<1, unsigned long> poly_uint64;
typedef poly_int<1, offset_int> poly_offset_int;
typedef poly_int<1, wide_int> poly_wide_int;
typedef poly_int<1, wide_int_ref> poly_wide_int_ref;
typedef poly_int<1, widest_int> poly_widest_int;
# 468 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "./insn-modes-inline.h" 1
# 10 "./insn-modes-inline.h"
inline __attribute__((__always_inline__))
poly_uint16
mode_size_inline (machine_mode mode)
{
extern poly_uint16_pod mode_size[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 18, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 4;
case E_CCGCmode: return 4;
case E_CCGOCmode: return 4;
case E_CCNOmode: return 4;
case E_CCGZmode: return 4;
case E_CCAmode: return 4;
case E_CCCmode: return 4;
case E_CCOmode: return 4;
case E_CCPmode: return 4;
case E_CCSmode: return 4;
case E_CCZmode: return 4;
case E_CCFPmode: return 4;
case E_BImode: return 1;
case E_QImode: return 1;
case E_HImode: return 2;
case E_SImode: return 4;
case E_DImode: return 8;
case E_TImode: return 16;
case E_OImode: return 32;
case E_XImode: return 64;
case E_P2QImode: return 2;
case E_P2HImode: return 4;
case E_POImode: return 32;
case E_QQmode: return 1;
case E_HQmode: return 2;
case E_SQmode: return 4;
case E_DQmode: return 8;
case E_TQmode: return 16;
case E_UQQmode: return 1;
case E_UHQmode: return 2;
case E_USQmode: return 4;
case E_UDQmode: return 8;
case E_UTQmode: return 16;
case E_HAmode: return 2;
case E_SAmode: return 4;
case E_DAmode: return 8;
case E_TAmode: return 16;
case E_UHAmode: return 2;
case E_USAmode: return 4;
case E_UDAmode: return 8;
case E_UTAmode: return 16;
case E_SFmode: return 4;
case E_DFmode: return 8;
case E_TFmode: return 16;
case E_SDmode: return 4;
case E_DDmode: return 8;
case E_TDmode: return 16;
case E_CQImode: return 2;
case E_CP2QImode: return 4;
case E_CHImode: return 4;
case E_CP2HImode: return 8;
case E_CSImode: return 8;
case E_CDImode: return 16;
case E_CTImode: return 32;
case E_CPOImode: return 64;
case E_COImode: return 64;
case E_CXImode: return 128;
case E_SCmode: return 8;
case E_DCmode: return 16;
case E_TCmode: return 32;
case E_V2QImode: return 2;
case E_V4QImode: return 4;
case E_V2HImode: return 4;
case E_V1SImode: return 4;
case E_V8QImode: return 8;
case E_V4HImode: return 8;
case E_V2SImode: return 8;
case E_V1DImode: return 8;
case E_V12QImode: return 12;
case E_V6HImode: return 12;
case E_V14QImode: return 14;
case E_V16QImode: return 16;
case E_V8HImode: return 16;
case E_V4SImode: return 16;
case E_V2DImode: return 16;
case E_V1TImode: return 16;
case E_V32QImode: return 32;
case E_V16HImode: return 32;
case E_V8SImode: return 32;
case E_V4DImode: return 32;
case E_V2TImode: return 32;
case E_V64QImode: return 64;
case E_V32HImode: return 64;
case E_V16SImode: return 64;
case E_V8DImode: return 64;
case E_V4TImode: return 64;
case E_V128QImode: return 128;
case E_V64HImode: return 128;
case E_V32SImode: return 128;
case E_V16DImode: return 128;
case E_V8TImode: return 128;
case E_V64SImode: return 256;
case E_V2SFmode: return 8;
case E_V4SFmode: return 16;
case E_V2DFmode: return 16;
case E_V8SFmode: return 32;
case E_V4DFmode: return 32;
case E_V2TFmode: return 32;
case E_V16SFmode: return 64;
case E_V8DFmode: return 64;
case E_V4TFmode: return 64;
case E_V32SFmode: return 128;
case E_V16DFmode: return 128;
case E_V8TFmode: return 128;
case E_V64SFmode: return 256;
case E_V32DFmode: return 256;
case E_V16TFmode: return 256;
default: return mode_size[mode];
}
}
inline __attribute__((__always_inline__))
poly_uint16
mode_nunits_inline (machine_mode mode)
{
extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 1;
case E_CCGCmode: return 1;
case E_CCGOCmode: return 1;
case E_CCNOmode: return 1;
case E_CCGZmode: return 1;
case E_CCAmode: return 1;
case E_CCCmode: return 1;
case E_CCOmode: return 1;
case E_CCPmode: return 1;
case E_CCSmode: return 1;
case E_CCZmode: return 1;
case E_CCFPmode: return 1;
case E_BImode: return 1;
case E_QImode: return 1;
case E_HImode: return 1;
case E_SImode: return 1;
case E_DImode: return 1;
case E_TImode: return 1;
case E_OImode: return 1;
case E_XImode: return 1;
case E_P2QImode: return 1;
case E_P2HImode: return 1;
case E_POImode: return 1;
case E_QQmode: return 1;
case E_HQmode: return 1;
case E_SQmode: return 1;
case E_DQmode: return 1;
case E_TQmode: return 1;
case E_UQQmode: return 1;
case E_UHQmode: return 1;
case E_USQmode: return 1;
case E_UDQmode: return 1;
case E_UTQmode: return 1;
case E_HAmode: return 1;
case E_SAmode: return 1;
case E_DAmode: return 1;
case E_TAmode: return 1;
case E_UHAmode: return 1;
case E_USAmode: return 1;
case E_UDAmode: return 1;
case E_UTAmode: return 1;
case E_SFmode: return 1;
case E_DFmode: return 1;
case E_XFmode: return 1;
case E_TFmode: return 1;
case E_SDmode: return 1;
case E_DDmode: return 1;
case E_TDmode: return 1;
case E_CQImode: return 2;
case E_CP2QImode: return 2;
case E_CHImode: return 2;
case E_CP2HImode: return 2;
case E_CSImode: return 2;
case E_CDImode: return 2;
case E_CTImode: return 2;
case E_CPOImode: return 2;
case E_COImode: return 2;
case E_CXImode: return 2;
case E_SCmode: return 2;
case E_DCmode: return 2;
case E_XCmode: return 2;
case E_TCmode: return 2;
case E_V2QImode: return 2;
case E_V4QImode: return 4;
case E_V2HImode: return 2;
case E_V1SImode: return 1;
case E_V8QImode: return 8;
case E_V4HImode: return 4;
case E_V2SImode: return 2;
case E_V1DImode: return 1;
case E_V12QImode: return 12;
case E_V6HImode: return 6;
case E_V14QImode: return 14;
case E_V16QImode: return 16;
case E_V8HImode: return 8;
case E_V4SImode: return 4;
case E_V2DImode: return 2;
case E_V1TImode: return 1;
case E_V32QImode: return 32;
case E_V16HImode: return 16;
case E_V8SImode: return 8;
case E_V4DImode: return 4;
case E_V2TImode: return 2;
case E_V64QImode: return 64;
case E_V32HImode: return 32;
case E_V16SImode: return 16;
case E_V8DImode: return 8;
case E_V4TImode: return 4;
case E_V128QImode: return 128;
case E_V64HImode: return 64;
case E_V32SImode: return 32;
case E_V16DImode: return 16;
case E_V8TImode: return 8;
case E_V64SImode: return 64;
case E_V2SFmode: return 2;
case E_V4SFmode: return 4;
case E_V2DFmode: return 2;
case E_V8SFmode: return 8;
case E_V4DFmode: return 4;
case E_V2TFmode: return 2;
case E_V16SFmode: return 16;
case E_V8DFmode: return 8;
case E_V4TFmode: return 4;
case E_V32SFmode: return 32;
case E_V16DFmode: return 16;
case E_V8TFmode: return 8;
case E_V64SFmode: return 64;
case E_V32DFmode: return 32;
case E_V16TFmode: return 16;
default: return mode_nunits[mode];
}
}
inline __attribute__((__always_inline__))
unsigned char
mode_inner_inline (machine_mode mode)
{
extern const unsigned char mode_inner[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 269, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return E_VOIDmode;
case E_BLKmode: return E_BLKmode;
case E_CCmode: return E_CCmode;
case E_CCGCmode: return E_CCGCmode;
case E_CCGOCmode: return E_CCGOCmode;
case E_CCNOmode: return E_CCNOmode;
case E_CCGZmode: return E_CCGZmode;
case E_CCAmode: return E_CCAmode;
case E_CCCmode: return E_CCCmode;
case E_CCOmode: return E_CCOmode;
case E_CCPmode: return E_CCPmode;
case E_CCSmode: return E_CCSmode;
case E_CCZmode: return E_CCZmode;
case E_CCFPmode: return E_CCFPmode;
case E_BImode: return E_BImode;
case E_QImode: return E_QImode;
case E_HImode: return E_HImode;
case E_SImode: return E_SImode;
case E_DImode: return E_DImode;
case E_TImode: return E_TImode;
case E_OImode: return E_OImode;
case E_XImode: return E_XImode;
case E_P2QImode: return E_P2QImode;
case E_P2HImode: return E_P2HImode;
case E_POImode: return E_POImode;
case E_QQmode: return E_QQmode;
case E_HQmode: return E_HQmode;
case E_SQmode: return E_SQmode;
case E_DQmode: return E_DQmode;
case E_TQmode: return E_TQmode;
case E_UQQmode: return E_UQQmode;
case E_UHQmode: return E_UHQmode;
case E_USQmode: return E_USQmode;
case E_UDQmode: return E_UDQmode;
case E_UTQmode: return E_UTQmode;
case E_HAmode: return E_HAmode;
case E_SAmode: return E_SAmode;
case E_DAmode: return E_DAmode;
case E_TAmode: return E_TAmode;
case E_UHAmode: return E_UHAmode;
case E_USAmode: return E_USAmode;
case E_UDAmode: return E_UDAmode;
case E_UTAmode: return E_UTAmode;
case E_SFmode: return E_SFmode;
case E_DFmode: return E_DFmode;
case E_XFmode: return E_XFmode;
case E_TFmode: return E_TFmode;
case E_SDmode: return E_SDmode;
case E_DDmode: return E_DDmode;
case E_TDmode: return E_TDmode;
case E_CQImode: return E_QImode;
case E_CP2QImode: return E_P2QImode;
case E_CHImode: return E_HImode;
case E_CP2HImode: return E_P2HImode;
case E_CSImode: return E_SImode;
case E_CDImode: return E_DImode;
case E_CTImode: return E_TImode;
case E_CPOImode: return E_POImode;
case E_COImode: return E_OImode;
case E_CXImode: return E_XImode;
case E_SCmode: return E_SFmode;
case E_DCmode: return E_DFmode;
case E_XCmode: return E_XFmode;
case E_TCmode: return E_TFmode;
case E_V2QImode: return E_QImode;
case E_V4QImode: return E_QImode;
case E_V2HImode: return E_HImode;
case E_V1SImode: return E_SImode;
case E_V8QImode: return E_QImode;
case E_V4HImode: return E_HImode;
case E_V2SImode: return E_SImode;
case E_V1DImode: return E_DImode;
case E_V12QImode: return E_QImode;
case E_V6HImode: return E_HImode;
case E_V14QImode: return E_QImode;
case E_V16QImode: return E_QImode;
case E_V8HImode: return E_HImode;
case E_V4SImode: return E_SImode;
case E_V2DImode: return E_DImode;
case E_V1TImode: return E_TImode;
case E_V32QImode: return E_QImode;
case E_V16HImode: return E_HImode;
case E_V8SImode: return E_SImode;
case E_V4DImode: return E_DImode;
case E_V2TImode: return E_TImode;
case E_V64QImode: return E_QImode;
case E_V32HImode: return E_HImode;
case E_V16SImode: return E_SImode;
case E_V8DImode: return E_DImode;
case E_V4TImode: return E_TImode;
case E_V128QImode: return E_QImode;
case E_V64HImode: return E_HImode;
case E_V32SImode: return E_SImode;
case E_V16DImode: return E_DImode;
case E_V8TImode: return E_TImode;
case E_V64SImode: return E_SImode;
case E_V2SFmode: return E_SFmode;
case E_V4SFmode: return E_SFmode;
case E_V2DFmode: return E_DFmode;
case E_V8SFmode: return E_SFmode;
case E_V4DFmode: return E_DFmode;
case E_V2TFmode: return E_TFmode;
case E_V16SFmode: return E_SFmode;
case E_V8DFmode: return E_DFmode;
case E_V4TFmode: return E_TFmode;
case E_V32SFmode: return E_SFmode;
case E_V16DFmode: return E_DFmode;
case E_V8TFmode: return E_TFmode;
case E_V64SFmode: return E_SFmode;
case E_V32DFmode: return E_DFmode;
case E_V16TFmode: return E_TFmode;
default: return mode_inner[mode];
}
}
inline __attribute__((__always_inline__))
unsigned char
mode_unit_size_inline (machine_mode mode)
{
extern unsigned char mode_unit_size[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 396, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 4;
case E_CCGCmode: return 4;
case E_CCGOCmode: return 4;
case E_CCNOmode: return 4;
case E_CCGZmode: return 4;
case E_CCAmode: return 4;
case E_CCCmode: return 4;
case E_CCOmode: return 4;
case E_CCPmode: return 4;
case E_CCSmode: return 4;
case E_CCZmode: return 4;
case E_CCFPmode: return 4;
case E_BImode: return 1;
case E_QImode: return 1;
case E_HImode: return 2;
case E_SImode: return 4;
case E_DImode: return 8;
case E_TImode: return 16;
case E_OImode: return 32;
case E_XImode: return 64;
case E_P2QImode: return 2;
case E_P2HImode: return 4;
case E_POImode: return 32;
case E_QQmode: return 1;
case E_HQmode: return 2;
case E_SQmode: return 4;
case E_DQmode: return 8;
case E_TQmode: return 16;
case E_UQQmode: return 1;
case E_UHQmode: return 2;
case E_USQmode: return 4;
case E_UDQmode: return 8;
case E_UTQmode: return 16;
case E_HAmode: return 2;
case E_SAmode: return 4;
case E_DAmode: return 8;
case E_TAmode: return 16;
case E_UHAmode: return 2;
case E_USAmode: return 4;
case E_UDAmode: return 8;
case E_UTAmode: return 16;
case E_SFmode: return 4;
case E_DFmode: return 8;
case E_TFmode: return 16;
case E_SDmode: return 4;
case E_DDmode: return 8;
case E_TDmode: return 16;
case E_CQImode: return 1;
case E_CP2QImode: return 2;
case E_CHImode: return 2;
case E_CP2HImode: return 4;
case E_CSImode: return 4;
case E_CDImode: return 8;
case E_CTImode: return 16;
case E_CPOImode: return 32;
case E_COImode: return 32;
case E_CXImode: return 64;
case E_SCmode: return 4;
case E_DCmode: return 8;
case E_TCmode: return 16;
case E_V2QImode: return 1;
case E_V4QImode: return 1;
case E_V2HImode: return 2;
case E_V1SImode: return 4;
case E_V8QImode: return 1;
case E_V4HImode: return 2;
case E_V2SImode: return 4;
case E_V1DImode: return 8;
case E_V12QImode: return 1;
case E_V6HImode: return 2;
case E_V14QImode: return 1;
case E_V16QImode: return 1;
case E_V8HImode: return 2;
case E_V4SImode: return 4;
case E_V2DImode: return 8;
case E_V1TImode: return 16;
case E_V32QImode: return 1;
case E_V16HImode: return 2;
case E_V8SImode: return 4;
case E_V4DImode: return 8;
case E_V2TImode: return 16;
case E_V64QImode: return 1;
case E_V32HImode: return 2;
case E_V16SImode: return 4;
case E_V8DImode: return 8;
case E_V4TImode: return 16;
case E_V128QImode: return 1;
case E_V64HImode: return 2;
case E_V32SImode: return 4;
case E_V16DImode: return 8;
case E_V8TImode: return 16;
case E_V64SImode: return 4;
case E_V2SFmode: return 4;
case E_V4SFmode: return 4;
case E_V2DFmode: return 8;
case E_V8SFmode: return 4;
case E_V4DFmode: return 8;
case E_V2TFmode: return 16;
case E_V16SFmode: return 4;
case E_V8DFmode: return 8;
case E_V4TFmode: return 16;
case E_V32SFmode: return 4;
case E_V16DFmode: return 8;
case E_V8TFmode: return 16;
case E_V64SFmode: return 4;
case E_V32DFmode: return 8;
case E_V16TFmode: return 16;
default: return mode_unit_size[mode];
}
}
inline __attribute__((__always_inline__))
unsigned short
mode_unit_precision_inline (machine_mode mode)
{
extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
((void)(!(mode >= 0 && mode < NUM_MACHINE_MODES) ? fancy_abort ("./insn-modes-inline.h", 521, __FUNCTION__), 0 : 0));
switch (mode)
{
case E_VOIDmode: return 0;
case E_BLKmode: return 0;
case E_CCmode: return 4*(8);
case E_CCGCmode: return 4*(8);
case E_CCGOCmode: return 4*(8);
case E_CCNOmode: return 4*(8);
case E_CCGZmode: return 4*(8);
case E_CCAmode: return 4*(8);
case E_CCCmode: return 4*(8);
case E_CCOmode: return 4*(8);
case E_CCPmode: return 4*(8);
case E_CCSmode: return 4*(8);
case E_CCZmode: return 4*(8);
case E_CCFPmode: return 4*(8);
case E_BImode: return 1;
case E_QImode: return 1*(8);
case E_HImode: return 2*(8);
case E_SImode: return 4*(8);
case E_DImode: return 8*(8);
case E_TImode: return 16*(8);
case E_OImode: return 32*(8);
case E_XImode: return 64*(8);
case E_P2QImode: return 16;
case E_P2HImode: return 32;
case E_POImode: return 160;
case E_QQmode: return 1*(8);
case E_HQmode: return 2*(8);
case E_SQmode: return 4*(8);
case E_DQmode: return 8*(8);
case E_TQmode: return 16*(8);
case E_UQQmode: return 1*(8);
case E_UHQmode: return 2*(8);
case E_USQmode: return 4*(8);
case E_UDQmode: return 8*(8);
case E_UTQmode: return 16*(8);
case E_HAmode: return 2*(8);
case E_SAmode: return 4*(8);
case E_DAmode: return 8*(8);
case E_TAmode: return 16*(8);
case E_UHAmode: return 2*(8);
case E_USAmode: return 4*(8);
case E_UDAmode: return 8*(8);
case E_UTAmode: return 16*(8);
case E_SFmode: return 4*(8);
case E_DFmode: return 8*(8);
case E_XFmode: return 80;
case E_TFmode: return 16*(8);
case E_SDmode: return 4*(8);
case E_DDmode: return 8*(8);
case E_TDmode: return 16*(8);
case E_CQImode: return 1*(8);
case E_CP2QImode: return 16;
case E_CHImode: return 2*(8);
case E_CP2HImode: return 32;
case E_CSImode: return 4*(8);
case E_CDImode: return 8*(8);
case E_CTImode: return 16*(8);
case E_CPOImode: return 160;
case E_COImode: return 32*(8);
case E_CXImode: return 64*(8);
case E_SCmode: return 4*(8);
case E_DCmode: return 8*(8);
case E_XCmode: return 80;
case E_TCmode: return 16*(8);
case E_V2QImode: return 1*(8);
case E_V4QImode: return 1*(8);
case E_V2HImode: return 2*(8);
case E_V1SImode: return 4*(8);
case E_V8QImode: return 1*(8);
case E_V4HImode: return 2*(8);
case E_V2SImode: return 4*(8);
case E_V1DImode: return 8*(8);
case E_V12QImode: return 1*(8);
case E_V6HImode: return 2*(8);
case E_V14QImode: return 1*(8);
case E_V16QImode: return 1*(8);
case E_V8HImode: return 2*(8);
case E_V4SImode: return 4*(8);
case E_V2DImode: return 8*(8);
case E_V1TImode: return 16*(8);
case E_V32QImode: return 1*(8);
case E_V16HImode: return 2*(8);
case E_V8SImode: return 4*(8);
case E_V4DImode: return 8*(8);
case E_V2TImode: return 16*(8);
case E_V64QImode: return 1*(8);
case E_V32HImode: return 2*(8);
case E_V16SImode: return 4*(8);
case E_V8DImode: return 8*(8);
case E_V4TImode: return 16*(8);
case E_V128QImode: return 1*(8);
case E_V64HImode: return 2*(8);
case E_V32SImode: return 4*(8);
case E_V16DImode: return 8*(8);
case E_V8TImode: return 16*(8);
case E_V64SImode: return 4*(8);
case E_V2SFmode: return 4*(8);
case E_V4SFmode: return 4*(8);
case E_V2DFmode: return 8*(8);
case E_V8SFmode: return 4*(8);
case E_V4DFmode: return 8*(8);
case E_V2TFmode: return 16*(8);
case E_V16SFmode: return 4*(8);
case E_V8DFmode: return 8*(8);
case E_V4TFmode: return 16*(8);
case E_V32SFmode: return 4*(8);
case E_V16DFmode: return 8*(8);
case E_V8TFmode: return 16*(8);
case E_V64SFmode: return 4*(8);
case E_V32DFmode: return 8*(8);
case E_V16TFmode: return 16*(8);
default: return mode_unit_precision[mode];
}
}
# 469 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
typedef opt_mode<machine_mode> opt_machine_mode;
extern poly_uint16_pod mode_size[NUM_MACHINE_MODES];
extern const poly_uint16_pod mode_precision[NUM_MACHINE_MODES];
extern const unsigned char mode_inner[NUM_MACHINE_MODES];
extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
extern unsigned char mode_unit_size[NUM_MACHINE_MODES];
extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
extern const unsigned char mode_wider[NUM_MACHINE_MODES];
extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
template<typename T>
struct mode_traits
{
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
enum from_int { dummy = MAX_MACHINE_MODE };
};
template<>
struct mode_traits<machine_mode>
{
typedef machine_mode from_int;
};
# 89 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
extern const char * const mode_name[NUM_MACHINE_MODES];
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/mode-classes.def" 1
# 95 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h" 2
enum mode_class { MODE_RANDOM, MODE_CC, MODE_INT, MODE_PARTIAL_INT, MODE_FRACT, MODE_UFRACT, MODE_ACCUM, MODE_UACCUM, MODE_FLOAT, MODE_DECIMAL_FLOAT, MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MODE_VECTOR_BOOL, MODE_VECTOR_INT, MODE_VECTOR_FRACT, MODE_VECTOR_UFRACT, MODE_VECTOR_ACCUM, MODE_VECTOR_UACCUM, MODE_VECTOR_FLOAT, MAX_MODE_CLASS };
extern const unsigned char mode_class[NUM_MACHINE_MODES];
# 241 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
template<typename T>
class opt_mode
{
public:
enum from_int { dummy = MAX_MACHINE_MODE };
inline __attribute__ ((always_inline)) constexpr opt_mode () : m_mode (E_VOIDmode) {}
inline __attribute__ ((always_inline)) constexpr opt_mode (const T &m) : m_mode (m) {}
template<typename U>
inline __attribute__ ((always_inline)) constexpr opt_mode (const U &m) : m_mode (T (m)) {}
inline __attribute__ ((always_inline)) constexpr opt_mode (from_int m) : m_mode (machine_mode (m)) {}
machine_mode else_void () const;
machine_mode else_blk () const { return else_mode (((void) 0, E_BLKmode)); }
machine_mode else_mode (machine_mode) const;
T require () const;
bool exists () const;
template<typename U> bool exists (U *) const;
bool operator== (const T &m) const { return m_mode == m; }
bool operator!= (const T &m) const { return m_mode != m; }
private:
machine_mode m_mode;
};
template<typename T>
inline __attribute__ ((always_inline)) machine_mode
opt_mode<T>::else_void () const
{
return m_mode;
}
template<typename T>
inline machine_mode
opt_mode<T>::else_mode (machine_mode fallback) const
{
return m_mode == E_VOIDmode ? fallback : m_mode;
}
template<typename T>
inline T
opt_mode<T>::require () const
{
((void)(!(m_mode != E_VOIDmode) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h", 293, __FUNCTION__), 0 : 0));
return typename mode_traits<T>::from_int (m_mode);
}
template<typename T>
inline __attribute__ ((always_inline)) bool
opt_mode<T>::exists () const
{
return m_mode != E_VOIDmode;
}
template<typename T>
template<typename U>
inline bool
opt_mode<T>::exists (U *mode) const
{
if (m_mode != E_VOIDmode)
{
*mode = T (typename mode_traits<T>::from_int (m_mode));
return true;
}
return false;
}
template<typename T>
struct pod_mode
{
typedef typename mode_traits<T>::from_int from_int;
typedef typename T::measurement_type measurement_type;
machine_mode m_mode;
inline __attribute__ ((always_inline)) constexpr
operator machine_mode () const { return m_mode; }
inline __attribute__ ((always_inline)) constexpr
operator T () const { return from_int (m_mode); }
inline __attribute__ ((always_inline)) pod_mode &operator = (const T &m) { m_mode = m; return *this; }
};
template<typename T>
inline bool
is_a (machine_mode m)
{
return T::includes_p (m);
}
template<typename T, typename U>
inline bool
is_a (const opt_mode<U> &m)
{
return T::includes_p (m.else_void ());
}
template<typename T>
inline T
as_a (machine_mode m)
{
((void)(!(T::includes_p (m)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h", 361, __FUNCTION__), 0 : 0));
return typename mode_traits<T>::from_int (m);
}
template<typename T, typename U>
inline T
as_a (const opt_mode<U> &m)
{
return as_a <T> (m.else_void ());
}
template<typename T>
inline opt_mode<T>
dyn_cast (machine_mode m)
{
if (T::includes_p (m))
return T (typename mode_traits<T>::from_int (m));
return opt_mode<T> ();
}
template<typename T, typename U>
inline opt_mode<T>
dyn_cast (const opt_mode<U> &m)
{
return dyn_cast <T> (m.else_void ());
}
template<typename T, typename U>
inline bool
is_a (machine_mode m, U *result)
{
if (T::includes_p (m))
{
*result = T (typename mode_traits<T>::from_int (m));
return true;
}
return false;
}
class scalar_int_mode
{
public:
typedef mode_traits<scalar_int_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) scalar_int_mode () {}
inline __attribute__ ((always_inline)) constexpr
scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
scalar_int_mode::includes_p (machine_mode m)
{
return (((enum mode_class) mode_class[m]) == MODE_INT || ((enum mode_class) mode_class[m]) == MODE_PARTIAL_INT);
}
class scalar_float_mode
{
public:
typedef mode_traits<scalar_float_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) scalar_float_mode () {}
inline __attribute__ ((always_inline)) constexpr
scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
scalar_float_mode::includes_p (machine_mode m)
{
return (((enum mode_class) mode_class[m]) == MODE_FLOAT || ((enum mode_class) mode_class[m]) == MODE_DECIMAL_FLOAT);
}
class scalar_mode
{
public:
typedef mode_traits<scalar_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) scalar_mode () {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (const scalar_int_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (const scalar_float_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
scalar_mode::includes_p (machine_mode m)
{
switch (((enum mode_class) mode_class[m]))
{
case MODE_INT:
case MODE_PARTIAL_INT:
case MODE_FRACT:
case MODE_UFRACT:
case MODE_ACCUM:
case MODE_UACCUM:
case MODE_FLOAT:
case MODE_DECIMAL_FLOAT:
return true;
default:
return false;
}
}
class complex_mode
{
public:
typedef mode_traits<complex_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) complex_mode () {}
inline __attribute__ ((always_inline)) constexpr
complex_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
complex_mode::includes_p (machine_mode m)
{
return (((enum mode_class) mode_class[m]) == MODE_COMPLEX_INT || ((enum mode_class) mode_class[m]) == MODE_COMPLEX_FLOAT);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_bytes (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_size_inline (mode) : mode_size[mode]);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_bits (machine_mode mode)
{
return mode_to_bytes (mode) * (8);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_precision (machine_mode mode)
{
return mode_precision[mode];
}
inline __attribute__ ((always_inline)) scalar_mode
mode_to_inner (machine_mode mode)
{
return scalar_mode::from_int (__builtin_constant_p (mode)
? mode_inner_inline (mode)
: mode_inner[mode]);
}
inline __attribute__ ((always_inline)) unsigned char
mode_to_unit_size (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_unit_size_inline (mode) : mode_unit_size[mode]);
}
inline __attribute__ ((always_inline)) unsigned short
mode_to_unit_precision (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
}
inline __attribute__ ((always_inline)) poly_uint16
mode_to_nunits (machine_mode mode)
{
return (__builtin_constant_p (mode)
? mode_nunits_inline (mode) : mode_nunits[mode]);
}
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_SIZE (machine_mode mode)
{
return mode_to_bytes (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_SIZE (const T &mode)
{
return mode_to_bytes (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_SIZE (const T &mode)
{
return mode_to_bytes (mode).coeffs[0];
}
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_BITSIZE (machine_mode mode)
{
return mode_to_bits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_BITSIZE (const T &mode)
{
return mode_to_bits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_BITSIZE (const T &mode)
{
return mode_to_bits (mode).coeffs[0];
}
# 679 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_PRECISION (machine_mode mode)
{
return mode_to_precision (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_PRECISION (const T &mode)
{
return mode_to_precision (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_PRECISION (const T &mode)
{
return mode_to_precision (mode).coeffs[0];
}
extern const unsigned char mode_ibit[NUM_MACHINE_MODES];
extern const unsigned char mode_fbit[NUM_MACHINE_MODES];
extern const unsigned long mode_mask_array[NUM_MACHINE_MODES];
# 737 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
inline __attribute__ ((always_inline)) poly_uint16
GET_MODE_NUNITS (machine_mode mode)
{
return mode_to_nunits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_poly<typename T::measurement_type>::type
GET_MODE_NUNITS (const T &mode)
{
return mode_to_nunits (mode);
}
template<typename T>
inline __attribute__ ((always_inline)) typename if_nonpoly<typename T::measurement_type>::type
GET_MODE_NUNITS (const T &mode)
{
return mode_to_nunits (mode).coeffs[0];
}
template<typename T>
inline __attribute__ ((always_inline)) opt_mode<T>
GET_MODE_WIDER_MODE (const T &m)
{
return typename opt_mode<T>::from_int (mode_wider[m]);
}
template<typename T>
inline __attribute__ ((always_inline)) opt_mode<T>
GET_MODE_2XWIDER_MODE (const T &m)
{
return typename opt_mode<T>::from_int (mode_2xwider[m]);
}
extern const unsigned char mode_complex[NUM_MACHINE_MODES];
class fixed_size_mode
{
public:
typedef mode_traits<fixed_size_mode>::from_int from_int;
typedef unsigned short measurement_type;
inline __attribute__ ((always_inline)) fixed_size_mode () {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr
fixed_size_mode (const complex_mode &m) : m_mode (m) {}
inline __attribute__ ((always_inline)) constexpr operator machine_mode () const { return m_mode; }
static bool includes_p (machine_mode);
protected:
machine_mode m_mode;
};
inline bool
fixed_size_mode::includes_p (machine_mode mode)
{
return mode_to_bytes (mode).is_constant ();
}
# 841 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
inline opt_scalar_int_mode
int_mode_for_size (poly_uint64 size, int limit)
{
return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
}
inline opt_scalar_float_mode
float_mode_for_size (poly_uint64 size)
{
return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
}
inline opt_scalar_float_mode
decimal_float_mode_for_size (unsigned int size)
{
return dyn_cast <scalar_float_mode>
(mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
}
extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
inline scalar_int_mode
smallest_int_mode_for_size (poly_uint64 size)
{
return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
}
extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode,
poly_uint64 = 0);
extern opt_machine_mode related_int_vector_mode (machine_mode);
class bit_field_mode_iterator
{
public:
bit_field_mode_iterator (long, long,
poly_int64, poly_int64,
unsigned int, bool);
bool next_mode (scalar_int_mode *);
bool prefer_smaller_modes ();
private:
opt_scalar_int_mode m_mode;
long m_bitsize;
long m_bitpos;
poly_int64 m_bitregion_start;
poly_int64 m_bitregion_end;
unsigned int m_align;
bool m_volatilep;
int m_count;
};
extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
unsigned long, bool, scalar_int_mode *);
extern unsigned short mode_base_align[NUM_MACHINE_MODES];
extern unsigned get_mode_alignment (machine_mode);
extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
# 939 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
template<typename T>
inline T
get_narrowest_mode (T mode)
{
return typename mode_traits<T>::from_int
(class_narrowest_mode[((enum mode_class) mode_class[mode])]);
}
extern scalar_int_mode byte_mode;
extern scalar_int_mode word_mode;
extern scalar_int_mode ptr_mode;
extern void init_adjust_machine_modes (void);
# 964 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
inline bool
HWI_COMPUTABLE_MODE_P (machine_mode mode)
{
machine_mode mme = mode;
return ((((enum mode_class) mode_class[mme]) == MODE_INT || ((enum mode_class) mode_class[mme]) == MODE_PARTIAL_INT)
&& mode_to_precision (mme).coeffs[0] <= 64);
}
inline bool
HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
{
return GET_MODE_PRECISION (mode) <= 64;
}
struct int_n_data_t {
unsigned int bitsize;
scalar_int_mode_pod m;
};
extern bool int_n_enabled_p[1];
extern const int_n_data_t int_n_data[1];
template<typename T>
inline bool
is_int_mode (machine_mode mode, T *int_mode)
{
if (((enum mode_class) mode_class[mode]) == MODE_INT)
{
*int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
return true;
}
return false;
}
template<typename T>
inline bool
is_float_mode (machine_mode mode, T *float_mode)
{
if (((enum mode_class) mode_class[mode]) == MODE_FLOAT)
{
*float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
return true;
}
return false;
}
template<typename T>
inline bool
is_complex_int_mode (machine_mode mode, T *cmode)
{
if (((enum mode_class) mode_class[mode]) == MODE_COMPLEX_INT)
{
*cmode = complex_mode (complex_mode::from_int (mode));
return true;
}
return false;
}
template<typename T>
inline bool
is_complex_float_mode (machine_mode mode, T *cmode)
{
if (((enum mode_class) mode_class[mode]) == MODE_COMPLEX_FLOAT)
{
*cmode = complex_mode (complex_mode::from_int (mode));
return true;
}
return false;
}
inline bool
is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
{
scalar_int_mode int_mode;
return (is_a <scalar_int_mode> (mode, &int_mode)
&& GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
}
namespace mode_iterator
{
template<typename T>
inline void
start (opt_mode<T> *iter, enum mode_class mclass)
{
if (((machine_mode) class_narrowest_mode[mclass]) == E_VOIDmode)
*iter = opt_mode<T> ();
else
*iter = as_a<T> (((machine_mode) class_narrowest_mode[mclass]));
}
inline void
start (machine_mode *iter, enum mode_class mclass)
{
*iter = ((machine_mode) class_narrowest_mode[mclass]);
}
template<typename T>
inline bool
iterate_p (opt_mode<T> *iter)
{
return iter->exists ();
}
inline bool
iterate_p (machine_mode *iter)
{
return *iter != E_VOIDmode;
}
template<typename T>
inline void
get_wider (opt_mode<T> *iter)
{
*iter = GET_MODE_WIDER_MODE (iter->require ());
}
inline void
get_wider (machine_mode *iter)
{
*iter = GET_MODE_WIDER_MODE (*iter).else_void ();
}
template<typename T>
inline void
get_known_wider (T *iter)
{
*iter = GET_MODE_WIDER_MODE (*iter).require ();
}
template<typename T>
inline void
get_2xwider (opt_mode<T> *iter)
{
*iter = GET_MODE_2XWIDER_MODE (iter->require ());
}
inline void
get_2xwider (machine_mode *iter)
{
*iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
}
}
# 1183 "/home/giulianob/gcc_git_gnu/gcc/gcc/machmode.h"
template<typename T>
void
gt_ggc_mx (pod_mode<T> *)
{
}
template<typename T>
void
gt_pch_nx (pod_mode<T> *)
{
}
template<typename T>
void
gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *)
{
}
# 470 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h" 1
# 49 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
struct double_int
{
static double_int from_uhwi (unsigned long cst);
static double_int from_shwi (long cst);
static double_int from_pair (long high, unsigned long low);
static double_int from_buffer (const unsigned char *buffer, int len);
static double_int mask (unsigned prec);
static double_int max_value (unsigned int prec, bool uns);
static double_int min_value (unsigned int prec, bool uns);
double_int &operator ++ ();
double_int &operator -- ();
double_int &operator *= (double_int);
double_int &operator += (double_int);
double_int &operator -= (double_int);
double_int &operator &= (double_int);
double_int &operator ^= (double_int);
double_int &operator |= (double_int);
long to_shwi () const;
unsigned long to_uhwi () const;
bool fits_uhwi () const;
bool fits_shwi () const;
bool fits_hwi (bool uns) const;
int trailing_zeros () const;
int popcount () const;
bool multiple_of (double_int, bool, double_int *) const;
double_int set_bit (unsigned) const;
double_int mul_with_sign (double_int, bool unsigned_p, bool *overflow) const;
double_int wide_mul_with_sign (double_int, bool unsigned_p,
double_int *higher, bool *overflow) const;
double_int add_with_sign (double_int, bool unsigned_p, bool *overflow) const;
double_int sub_with_overflow (double_int, bool *overflow) const;
double_int neg_with_overflow (bool *overflow) const;
double_int operator * (double_int) const;
double_int operator + (double_int) const;
double_int operator - (double_int) const;
double_int operator - () const;
double_int operator ~ () const;
double_int operator & (double_int) const;
double_int operator | (double_int) const;
double_int operator ^ (double_int) const;
double_int and_not (double_int) const;
double_int lshift (long count) const;
double_int lshift (long count, unsigned int prec, bool arith) const;
double_int rshift (long count) const;
double_int rshift (long count, unsigned int prec, bool arith) const;
double_int alshift (long count, unsigned int prec) const;
double_int arshift (long count, unsigned int prec) const;
double_int llshift (long count, unsigned int prec) const;
double_int lrshift (long count, unsigned int prec) const;
double_int lrotate (long count, unsigned int prec) const;
double_int rrotate (long count, unsigned int prec) const;
double_int div (double_int, bool, unsigned) const;
double_int sdiv (double_int, unsigned) const;
double_int udiv (double_int, unsigned) const;
double_int mod (double_int, bool, unsigned) const;
double_int smod (double_int, unsigned) const;
double_int umod (double_int, unsigned) const;
double_int divmod_with_overflow (double_int, bool, unsigned,
double_int *, bool *) const;
double_int divmod (double_int, bool, unsigned, double_int *) const;
double_int sdivmod (double_int, unsigned, double_int *) const;
double_int udivmod (double_int, unsigned, double_int *) const;
double_int ext (unsigned prec, bool uns) const;
double_int zext (unsigned prec) const;
double_int sext (unsigned prec) const;
bool is_zero () const;
bool is_one () const;
bool is_minus_one () const;
bool is_negative () const;
int cmp (double_int b, bool uns) const;
int ucmp (double_int b) const;
int scmp (double_int b) const;
bool ult (double_int b) const;
bool ule (double_int b) const;
bool ugt (double_int b) const;
bool slt (double_int b) const;
bool sle (double_int b) const;
bool sgt (double_int b) const;
double_int max (double_int b, bool uns);
double_int smax (double_int b);
double_int umax (double_int b);
double_int min (double_int b, bool uns);
double_int smin (double_int b);
double_int umin (double_int b);
bool operator == (double_int cst2) const;
bool operator != (double_int cst2) const;
unsigned long low;
long high;
};
# 207 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
inline double_int
double_int::from_shwi (long cst)
{
double_int r;
r.low = (unsigned long) cst;
r.high = cst < 0 ? -1 : 0;
return r;
}
# 230 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
inline double_int
double_int::from_uhwi (unsigned long cst)
{
double_int r;
r.low = cst;
r.high = 0;
return r;
}
inline double_int
double_int::from_pair (long high, unsigned long low)
{
double_int r;
r.low = low;
r.high = high;
return r;
}
inline double_int &
double_int::operator ++ ()
{
*this += (double_int::from_shwi (1));
return *this;
}
inline double_int &
double_int::operator -- ()
{
*this -= (double_int::from_shwi (1));
return *this;
}
inline double_int &
double_int::operator &= (double_int b)
{
*this = *this & b;
return *this;
}
inline double_int &
double_int::operator ^= (double_int b)
{
*this = *this ^ b;
return *this;
}
inline double_int &
double_int::operator |= (double_int b)
{
*this = *this | b;
return *this;
}
inline long
double_int::to_shwi () const
{
return (long) low;
}
inline unsigned long
double_int::to_uhwi () const
{
return low;
}
inline bool
double_int::fits_uhwi () const
{
return high == 0;
}
inline double_int
double_int::operator ~ () const
{
double_int result;
result.low = ~low;
result.high = ~high;
return result;
}
inline double_int
double_int::operator | (double_int b) const
{
double_int result;
result.low = low | b.low;
result.high = high | b.high;
return result;
}
inline double_int
double_int::operator & (double_int b) const
{
double_int result;
result.low = low & b.low;
result.high = high & b.high;
return result;
}
inline double_int
double_int::and_not (double_int b) const
{
double_int result;
result.low = low & ~b.low;
result.high = high & ~b.high;
return result;
}
inline double_int
double_int::operator ^ (double_int b) const
{
double_int result;
result.low = low ^ b.low;
result.high = high ^ b.high;
return result;
}
void dump_double_int (FILE *, double_int, bool);
# 376 "/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h"
inline bool
double_int::is_zero () const
{
return low == 0 && high == 0;
}
inline bool
double_int::is_one () const
{
return low == 1 && high == 0;
}
inline bool
double_int::is_minus_one () const
{
return low == -1UL && high == -1;
}
inline bool
double_int::is_negative () const
{
return high < 0;
}
inline bool
double_int::operator == (double_int cst2) const
{
return low == cst2.low && high == cst2.high;
}
inline bool
double_int::operator != (double_int cst2) const
{
return low != cst2.low || high != cst2.high;
}
inline int
double_int::popcount () const
{
return popcount_hwi (high) + popcount_hwi (low);
}
void mpz_set_double_int (mpz_t, double_int, bool);
double_int mpz_get_double_int (const_tree, mpz_t, bool);
namespace wi
{
template <>
struct int_traits <double_int>
{
static const enum precision_type precision_type = CONST_PRECISION;
static const bool host_dependent_precision = true;
static const unsigned int precision = (2 * 64);
static unsigned int get_precision (const double_int &);
static wi::storage_ref decompose (long *, unsigned int,
const double_int &);
};
}
inline unsigned int
wi::int_traits <double_int>::get_precision (const double_int &)
{
return precision;
}
inline wi::storage_ref
wi::int_traits <double_int>::decompose (long *scratch, unsigned int p,
const double_int &x)
{
((void)(!(precision == p) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/double-int.h", 462, __FUNCTION__), 0 : 0));
scratch[0] = x.low;
if ((x.high == 0 && scratch[0] >= 0) || (x.high == -1 && scratch[0] < 0))
return wi::storage_ref (scratch, 1, precision);
scratch[1] = x.high;
return wi::storage_ref (scratch, 2, precision);
}
# 471 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/align.h" 1
# 22 "/home/giulianob/gcc_git_gnu/gcc/gcc/align.h"
struct align_flags_tuple
{
int log;
int maxskip;
void normalize ()
{
int n = (1 << log);
if (maxskip > n)
maxskip = n - 1;
}
int get_value ()
{
return maxskip + 1;
}
};
class align_flags
{
public:
align_flags (int log0 = 0, int maxskip0 = 0, int log1 = 0, int maxskip1 = 0)
{
levels[0].log = log0;
levels[0].maxskip = maxskip0;
levels[1].log = log1;
levels[1].maxskip = maxskip1;
normalize ();
}
void normalize ()
{
for (unsigned i = 0; i < 2; i++)
levels[i].normalize ();
}
static align_flags max (const align_flags f0, const align_flags f1)
{
int log0 = ((f0.levels[0].log) > (f1.levels[0].log) ? (f0.levels[0].log) : (f1.levels[0].log));
int maxskip0 = ((f0.levels[0].maxskip) > (f1.levels[0].maxskip) ? (f0.levels[0].maxskip) : (f1.levels[0].maxskip));
int log1 = ((f0.levels[1].log) > (f1.levels[1].log) ? (f0.levels[1].log) : (f1.levels[1].log));
int maxskip1 = ((f0.levels[1].maxskip) > (f1.levels[1].maxskip) ? (f0.levels[1].maxskip) : (f1.levels[1].maxskip));
return align_flags (log0, maxskip0, log1, maxskip1);
}
align_flags_tuple levels[2];
};
# 472 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h" 1
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
enum real_value_class {
rvc_zero,
rvc_normal,
rvc_inf,
rvc_nan
};
struct real_value {
unsigned int cl : 2;
unsigned int decimal : 1;
unsigned int sign : 1;
unsigned int signalling : 1;
unsigned int canonical : 1;
unsigned int uexp : (32 - 6);
unsigned long sig[((128 + (8 * 8)) / (8 * 8))];
};
# 80 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern char test_real_width
[sizeof (struct real_value) <= (((128 + (8 * 8)) + 32)/64 + (((128 + (8 * 8)) + 32)%64 ? 1 : 0)) * sizeof (long) ? 1 : -1];
# 118 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
struct real_format
{
void (*encode) (const struct real_format *, long *,
const struct real_value *);
void (*decode) (const struct real_format *, struct real_value *,
const long *);
int b;
int p;
int pnan;
int emin;
int emax;
int signbit_ro;
int signbit_rw;
# 158 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
int ieee_bits;
bool round_towards_zero;
bool has_sign_dependent_rounding;
bool has_nans;
bool has_inf;
bool has_denorm;
bool has_signed_zero;
bool qnan_msb_set;
bool canonical_nan_lsbs_set;
const char *name;
};
extern const struct real_format *
real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1
+ MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1];
# 217 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
class format_helper
{
public:
format_helper (const real_format *format) : m_format (format) {}
template<typename T> format_helper (const T &);
const real_format *operator-> () const { return m_format; }
operator const real_format *() const { return m_format; }
bool decimal_p () const { return m_format && m_format->b == 10; }
bool can_represent_integral_type_p (tree type) const;
private:
const real_format *m_format;
};
template<typename T>
inline format_helper::format_helper (const T &m)
: m_format (m == ((void) 0, E_VOIDmode) ? 0 : (real_format_for_mode[(((enum mode_class) mode_class[m]) == MODE_DECIMAL_FLOAT) ? (((m) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class) mode_class[m]) == MODE_FLOAT ? ((m) - MIN_MODE_FLOAT) : ((fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/real.h", 234, __FUNCTION__)), 0)]))
{}
# 244 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern bool HONOR_NANS (machine_mode);
extern bool HONOR_NANS (const_tree);
extern bool HONOR_NANS (const_rtx);
extern bool HONOR_SNANS (machine_mode);
extern bool HONOR_SNANS (const_tree);
extern bool HONOR_SNANS (const_rtx);
extern bool HONOR_INFINITIES (machine_mode);
extern bool HONOR_INFINITIES (const_tree);
extern bool HONOR_INFINITIES (const_rtx);
extern bool HONOR_SIGNED_ZEROS (machine_mode);
extern bool HONOR_SIGNED_ZEROS (const_tree);
extern bool HONOR_SIGNED_ZEROS (const_rtx);
extern bool HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode);
extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_tree);
extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx);
extern bool real_arithmetic (struct real_value *, int, const struct real_value *,
const struct real_value *);
extern bool real_compare (int, const struct real_value *, const struct real_value *);
extern bool real_isinf (const struct real_value *);
extern bool real_isnan (const struct real_value *);
extern bool real_issignaling_nan (const struct real_value *);
extern bool real_isfinite (const struct real_value *);
extern bool real_isneg (const struct real_value *);
extern bool real_isnegzero (const struct real_value *);
extern bool real_identical (const struct real_value *, const struct real_value *);
extern bool real_equal (const struct real_value *, const struct real_value *);
extern bool real_less (const struct real_value *, const struct real_value *);
extern void real_convert (struct real_value *, format_helper,
const struct real_value *);
extern bool exact_real_truncate (format_helper, const struct real_value *);
extern void real_to_decimal (char *, const struct real_value *, size_t,
size_t, int);
extern void real_to_decimal_for_mode (char *, const struct real_value *, size_t,
size_t, int, machine_mode);
extern void real_to_hexadecimal (char *, const struct real_value *,
size_t, size_t, int);
extern long real_to_integer (const struct real_value *);
extern int real_from_string (struct real_value *, const char *);
extern void real_from_string3 (struct real_value *, const char *, format_helper);
extern long real_to_target (long *, const struct real_value *, format_helper);
extern void real_from_target (struct real_value *, const long *,
format_helper);
extern void real_inf (struct real_value *);
extern bool real_nan (struct real_value *, const char *, int, format_helper);
extern void real_maxval (struct real_value *, int, machine_mode);
extern void real_2expN (struct real_value *, int, format_helper);
extern unsigned int real_hash (const struct real_value *);
extern const struct real_format ieee_single_format;
extern const struct real_format mips_single_format;
extern const struct real_format motorola_single_format;
extern const struct real_format spu_single_format;
extern const struct real_format ieee_double_format;
extern const struct real_format mips_double_format;
extern const struct real_format motorola_double_format;
extern const struct real_format ieee_extended_motorola_format;
extern const struct real_format ieee_extended_intel_96_format;
extern const struct real_format ieee_extended_intel_96_round_53_format;
extern const struct real_format ieee_extended_intel_128_format;
extern const struct real_format ibm_extended_format;
extern const struct real_format mips_extended_format;
extern const struct real_format ieee_quad_format;
extern const struct real_format mips_quad_format;
extern const struct real_format vax_f_format;
extern const struct real_format vax_d_format;
extern const struct real_format vax_g_format;
extern const struct real_format real_internal_format;
extern const struct real_format decimal_single_format;
extern const struct real_format decimal_double_format;
extern const struct real_format decimal_quad_format;
extern const struct real_format ieee_half_format;
extern const struct real_format arm_half_format;
extern const struct real_format arm_bfloat_half_format;
# 418 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern struct real_value real_value_truncate (format_helper, struct real_value);
extern struct real_value real_value_negate (const struct real_value *);
extern struct real_value real_value_abs (const struct real_value *);
extern int significand_size (format_helper);
extern struct real_value real_from_string2 (const char *, format_helper);
# 443 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern int real_exponent (const struct real_value *);
extern void real_ldexp (struct real_value *, const struct real_value *, int);
extern struct real_value dconst0;
extern struct real_value dconst1;
extern struct real_value dconst2;
extern struct real_value dconstm1;
extern struct real_value dconsthalf;
# 466 "/home/giulianob/gcc_git_gnu/gcc/gcc/real.h"
extern const struct real_value * dconst_e_ptr (void);
extern const struct real_value *dconst_third_ptr (void);
extern const struct real_value *dconst_quarter_ptr (void);
extern const struct real_value *dconst_sixth_ptr (void);
extern const struct real_value *dconst_ninth_ptr (void);
extern const struct real_value * dconst_sqrt2_ptr (void);
struct real_value real_value_from_int_cst (const_tree, const_tree);
extern rtx const_double_from_real_value (struct real_value, machine_mode);
extern bool exact_real_inverse (format_helper, struct real_value *);
bool real_can_shorten_arithmetic (machine_mode, machine_mode);
extern tree build_real (tree, struct real_value);
extern tree build_real_truncate (tree, struct real_value);
extern bool real_powi (struct real_value *, format_helper,
const struct real_value *, long);
extern void real_trunc (struct real_value *, format_helper,
const struct real_value *);
extern void real_floor (struct real_value *, format_helper,
const struct real_value *);
extern void real_ceil (struct real_value *, format_helper,
const struct real_value *);
extern void real_round (struct real_value *, format_helper,
const struct real_value *);
extern void real_roundeven (struct real_value *, format_helper,
const struct real_value *);
extern void real_copysign (struct real_value *, const struct real_value *);
extern bool real_isinteger (const struct real_value *, format_helper);
extern bool real_isinteger (const struct real_value *, long *);
extern bool real_nextafter (struct real_value *, format_helper,
const struct real_value *, const struct real_value *);
extern void get_max_float (const struct real_format *, char *, size_t, bool);
extern wide_int real_to_integer (const struct real_value *, bool *, int);
extern void real_from_integer (struct real_value *, format_helper,
const wide_int_ref &, signop);
extern void build_sinatan_real (struct real_value *, tree);
# 475 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h"
struct fixed_value
{
double_int data;
scalar_mode_pod mode;
};
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h"
extern struct fixed_value fconst0[18];
extern struct fixed_value fconst1[8];
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/fixed-value.h"
extern rtx const_fixed_from_fixed_value (struct fixed_value, machine_mode);
extern struct fixed_value fixed_from_double_int (double_int, scalar_mode);
static inline rtx
const_fixed_from_double_int (double_int payload,
scalar_mode mode)
{
return
const_fixed_from_fixed_value (fixed_from_double_int (payload, mode),
mode);
}
extern void fixed_from_string (struct fixed_value *, const char *,
scalar_mode);
extern tree build_fixed (tree, struct fixed_value);
extern bool fixed_convert (struct fixed_value *, scalar_mode,
const struct fixed_value *, bool);
extern bool fixed_convert_from_int (struct fixed_value *, scalar_mode,
double_int, bool, bool);
extern bool fixed_convert_from_real (struct fixed_value *, scalar_mode,
const struct real_value *, bool);
extern void real_convert_from_fixed (struct real_value *, scalar_mode,
const struct fixed_value *);
extern bool fixed_identical (const struct fixed_value *, const struct fixed_value *);
extern unsigned int fixed_hash (const struct fixed_value *);
extern void fixed_to_decimal (char *str, const struct fixed_value *, size_t);
extern bool fixed_arithmetic (struct fixed_value *, int, const struct fixed_value *,
const struct fixed_value *, bool);
extern bool fixed_compare (int, const struct fixed_value *,
const struct fixed_value *);
extern bool fixed_isneg (const struct fixed_value *);
# 476 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 1
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/statistics.h" 1
# 61 "/home/giulianob/gcc_git_gnu/gcc/gcc/statistics.h"
struct function;
extern void statistics_early_init (void);
extern void statistics_init (void);
extern void statistics_fini (void);
extern void statistics_fini_pass (void);
extern void statistics_counter_event (struct function *, const char *, int);
extern void statistics_histogram_event (struct function *, const char *, int);
# 247 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h" 1
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h"
# 1 "./gtype-desc.h" 1
# 31 "./gtype-desc.h"
extern void gt_ggc_mx_line_maps (void *);
extern void gt_ggc_mx_cpp_token (void *);
extern void gt_ggc_mx_cpp_macro (void *);
extern void gt_ggc_mx_string_concat (void *);
extern void gt_ggc_mx_string_concat_db (void *);
extern void gt_ggc_mx_hash_map_location_hash_string_concat__ (void *);
extern void gt_ggc_mx_bitmap_head (void *);
extern void gt_ggc_mx_rtx_def (void *);
extern void gt_ggc_mx_rtvec_def (void *);
extern void gt_ggc_mx_gimple (void *);
extern void gt_ggc_mx_symtab_node (void *);
extern void gt_ggc_mx_cgraph_edge (void *);
extern void gt_ggc_mx_section (void *);
extern void gt_ggc_mx_cl_target_option (void *);
extern void gt_ggc_mx_cl_optimization (void *);
extern void gt_ggc_mx_edge_def (void *);
extern void gt_ggc_mx_basic_block_def (void *);
extern void gt_ggc_mx_stack_local_entry (void *);
extern void gt_ggc_mx_machine_function (void *);
extern void gt_ggc_mx_bitmap_element (void *);
extern void gt_ggc_mx_generic_wide_int_wide_int_storage_ (void *);
extern void gt_ggc_mx_coverage_data (void *);
extern void gt_ggc_mx_mem_attrs (void *);
extern void gt_ggc_mx_reg_attrs (void *);
extern void gt_ggc_mx_object_block (void *);
extern void gt_ggc_mx_vec_rtx_va_gc_ (void *);
extern void gt_ggc_mx_real_value (void *);
extern void gt_ggc_mx_fixed_value (void *);
extern void gt_ggc_mx_constant_descriptor_rtx (void *);
extern void gt_ggc_mx_function (void *);
extern void gt_ggc_mx_target_rtl (void *);
extern void gt_ggc_mx_cgraph_rtl_info (void *);
extern void gt_ggc_mx_hash_map_tree_tree_decl_tree_cache_traits_ (void *);
extern void gt_ggc_mx_hash_map_tree_tree_type_tree_cache_traits_ (void *);
extern void gt_ggc_mx_ptr_info_def (void *);
extern void gt_ggc_mx_range_info_def (void *);
extern void gt_ggc_mx_die_struct (void *);
extern void gt_ggc_mx_vec_constructor_elt_va_gc_ (void *);
extern void gt_ggc_mx_vec_tree_va_gc_ (void *);
extern void gt_ggc_mx_lang_type (void *);
extern void gt_ggc_mx_lang_decl (void *);
extern void gt_ggc_mx_tree_statement_list_node (void *);
extern void gt_ggc_mx_target_globals (void *);
extern void gt_ggc_mx_lang_tree_node (void *);
extern void gt_ggc_mx_tree_map (void *);
extern void gt_ggc_mx_tree_decl_map (void *);
extern void gt_ggc_mx_tree_int_map (void *);
extern void gt_ggc_mx_tree_vec_map (void *);
extern void gt_ggc_mx_vec_alias_pair_va_gc_ (void *);
extern void gt_ggc_mx_libfunc_entry (void *);
extern void gt_ggc_mx_hash_table_libfunc_hasher_ (void *);
extern void gt_ggc_mx_target_libfuncs (void *);
extern void gt_ggc_mx_sequence_stack (void *);
extern void gt_ggc_mx_vec_rtx_insn__va_gc_ (void *);
extern void gt_ggc_mx_call_site_record_d (void *);
extern void gt_ggc_mx_vec_uchar_va_gc_ (void *);
extern void gt_ggc_mx_vec_call_site_record_va_gc_ (void *);
extern void gt_ggc_mx_gimple_df (void *);
extern void gt_ggc_mx_dw_fde_node (void *);
extern void gt_ggc_mx_rtx_constant_pool (void *);
extern void gt_ggc_mx_frame_space (void *);
extern void gt_ggc_mx_vec_callinfo_callee_va_gc_ (void *);
extern void gt_ggc_mx_vec_callinfo_dalloc_va_gc_ (void *);
extern void gt_ggc_mx_stack_usage (void *);
extern void gt_ggc_mx_eh_status (void *);
extern void gt_ggc_mx_control_flow_graph (void *);
extern void gt_ggc_mx_loops (void *);
extern void gt_ggc_mx_language_function (void *);
extern void gt_ggc_mx_hash_set_tree_ (void *);
extern void gt_ggc_mx_types_used_by_vars_entry (void *);
extern void gt_ggc_mx_hash_table_used_type_hasher_ (void *);
extern void gt_ggc_mx_nb_iter_bound (void *);
extern void gt_ggc_mx_loop_exit (void *);
extern void gt_ggc_mx_loop (void *);
extern void gt_ggc_mx_control_iv (void *);
extern void gt_ggc_mx_vec_loop_p_va_gc_ (void *);
extern void gt_ggc_mx_niter_desc (void *);
extern void gt_ggc_mx_hash_table_loop_exit_hasher_ (void *);
extern void gt_ggc_mx_vec_basic_block_va_gc_ (void *);
extern void gt_ggc_mx_rtl_bb_info (void *);
extern void gt_ggc_mx_vec_edge_va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_ref_t_va_gc_ (void *);
extern void gt_ggc_mx_section_hash_entry (void *);
extern void gt_ggc_mx_lto_file_decl_data (void *);
extern void gt_ggc_mx_ipa_replace_map (void *);
extern void gt_ggc_mx_vec_ipa_replace_map__va_gc_ (void *);
extern void gt_ggc_mx_ipa_param_adjustments (void *);
extern void gt_ggc_mx_vec_ipa_param_performed_split_va_gc_ (void *);
extern void gt_ggc_mx_cgraph_simd_clone (void *);
extern void gt_ggc_mx_cgraph_function_version_info (void *);
extern void gt_ggc_mx_hash_table_cgraph_edge_hasher_ (void *);
extern void gt_ggc_mx_cgraph_indirect_call_info (void *);
extern void gt_ggc_mx_asm_node (void *);
extern void gt_ggc_mx_symbol_table (void *);
extern void gt_ggc_mx_hash_table_section_name_hasher_ (void *);
extern void gt_ggc_mx_hash_table_asmname_hasher_ (void *);
extern void gt_ggc_mx_hash_map_symtab_node__symbol_priority_map_ (void *);
extern void gt_ggc_mx_constant_descriptor_tree (void *);
extern void gt_ggc_mx_hash_map_alias_set_hash_int_ (void *);
extern void gt_ggc_mx_alias_set_entry (void *);
extern void gt_ggc_mx_vec_alias_set_entry__va_gc_ (void *);
extern void gt_ggc_mx_hash_table_function_version_hasher_ (void *);
extern void gt_ggc_mx_lto_in_decl_state (void *);
extern void gt_ggc_mx_hash_table_ipa_bit_ggc_hash_traits_ (void *);
extern void gt_ggc_mx_hash_table_ipa_vr_ggc_hash_traits_ (void *);
extern void gt_ggc_mx_ipa_node_params (void *);
extern void gt_ggc_mx_ipa_edge_args (void *);
extern void gt_ggc_mx_ipa_agg_replacement_value (void *);
extern void gt_ggc_mx_ipa_fn_summary (void *);
extern void gt_ggc_mx_odr_type_d (void *);
extern void gt_ggc_mx_vec_ipa_adjusted_param_va_gc_ (void *);
extern void gt_ggc_mx_param_access (void *);
extern void gt_ggc_mx_vec_param_access__va_gc_ (void *);
extern void gt_ggc_mx_isra_func_summary (void *);
extern void gt_ggc_mx_vec_isra_param_desc_va_gc_ (void *);
extern void gt_ggc_mx_ipa_sra_function_summaries (void *);
extern void gt_ggc_mx_typeinfo (void *);
extern void gt_ggc_mx_dw_cfi_node (void *);
extern void gt_ggc_mx_dw_loc_descr_node (void *);
extern void gt_ggc_mx_dw_loc_list_struct (void *);
extern void gt_ggc_mx_dw_discr_list_node (void *);
extern void gt_ggc_mx_dw_cfa_location (void *);
extern void gt_ggc_mx_vec_dw_cfi_ref_va_gc_ (void *);
extern void gt_ggc_mx_addr_table_entry (void *);
extern void gt_ggc_mx_indirect_string_node (void *);
extern void gt_ggc_mx_dwarf_file_data (void *);
extern void gt_ggc_mx_hash_map_char__tree_ (void *);
extern void gt_ggc_mx_dw_cfi_row (void *);
extern void gt_ggc_mx_reg_saved_in_data (void *);
extern void gt_ggc_mx_vec_dw_fde_ref_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_indirect_string_hasher_ (void *);
extern void gt_ggc_mx_comdat_type_node (void *);
extern void gt_ggc_mx_vec_dw_line_info_entry_va_gc_ (void *);
extern void gt_ggc_mx_dw_line_info_table (void *);
extern void gt_ggc_mx_vec_dw_attr_node_va_gc_ (void *);
extern void gt_ggc_mx_limbo_die_struct (void *);
extern void gt_ggc_mx_hash_table_dwarf_file_hasher_ (void *);
extern void gt_ggc_mx_hash_table_decl_die_hasher_ (void *);
extern void gt_ggc_mx_vec_dw_die_ref_va_gc_ (void *);
extern void gt_ggc_mx_variable_value_struct (void *);
extern void gt_ggc_mx_hash_table_variable_value_hasher_ (void *);
extern void gt_ggc_mx_hash_table_block_die_hasher_ (void *);
extern void gt_ggc_mx_var_loc_node (void *);
extern void gt_ggc_mx_var_loc_list_def (void *);
extern void gt_ggc_mx_call_arg_loc_node (void *);
extern void gt_ggc_mx_hash_table_decl_loc_hasher_ (void *);
extern void gt_ggc_mx_cached_dw_loc_list_def (void *);
extern void gt_ggc_mx_hash_table_dw_loc_list_hasher_ (void *);
extern void gt_ggc_mx_vec_dw_line_info_table__va_gc_ (void *);
extern void gt_ggc_mx_vec_pubname_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_macinfo_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_dw_ranges_va_gc_ (void *);
extern void gt_ggc_mx_vec_dw_ranges_by_label_va_gc_ (void *);
extern void gt_ggc_mx_vec_die_arg_entry_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_addr_hasher_ (void *);
extern void gt_ggc_mx_hash_map_tree_sym_off_pair_ (void *);
extern void gt_ggc_mx_inline_entry_data (void *);
extern void gt_ggc_mx_hash_table_inline_entry_data_hasher_ (void *);
extern void gt_ggc_mx_temp_slot (void *);
extern void gt_ggc_mx_initial_value_struct (void *);
extern void gt_ggc_mx_vec_temp_slot_p_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_const_int_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_wide_int_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_poly_int_hasher_ (void *);
extern void gt_ggc_mx_hash_table_reg_attr_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_double_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_fixed_hasher_ (void *);
extern void gt_ggc_mx_eh_region_d (void *);
extern void gt_ggc_mx_eh_landing_pad_d (void *);
extern void gt_ggc_mx_eh_catch_d (void *);
extern void gt_ggc_mx_vec_eh_region_va_gc_ (void *);
extern void gt_ggc_mx_vec_eh_landing_pad_va_gc_ (void *);
extern void gt_ggc_mx_hash_map_gimple__int_ (void *);
extern void gt_ggc_mx_hash_table_insn_cache_hasher_ (void *);
extern void gt_ggc_mx_temp_slot_address_entry (void *);
extern void gt_ggc_mx_hash_table_temp_address_hasher_ (void *);
extern void gt_ggc_mx_hash_map_tree_hash_tree_ (void *);
extern void gt_ggc_mx_test_struct (void *);
extern void gt_ggc_mx_test_of_length (void *);
extern void gt_ggc_mx_test_other (void *);
extern void gt_ggc_mx_test_of_union (void *);
extern void gt_ggc_mx_example_base (void *);
extern void gt_ggc_mx_test_node (void *);
extern void gt_ggc_mx_user_struct (void *);
extern void gt_ggc_mx_hash_table_libfunc_decl_hasher_ (void *);
extern void gt_ggc_mx_string_pool_data (void *);
extern void gt_ggc_mx_type_hash (void *);
extern void gt_ggc_mx_hash_table_type_cache_hasher_ (void *);
extern void gt_ggc_mx_hash_table_int_cst_hasher_ (void *);
extern void gt_ggc_mx_hash_table_poly_int_cst_hasher_ (void *);
extern void gt_ggc_mx_hash_table_cl_option_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tree_decl_map_cache_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tree_vec_map_cache_hasher_ (void *);
extern void gt_ggc_mx_hash_table_section_hasher_ (void *);
extern void gt_ggc_mx_hash_table_object_block_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tree_descriptor_hasher_ (void *);
extern void gt_ggc_mx_hash_table_const_rtx_desc_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tm_clone_hasher_ (void *);
extern void gt_ggc_mx_tm_restart_node (void *);
extern void gt_ggc_mx_hash_map_tree_tree_ (void *);
extern void gt_ggc_mx_hash_table_ssa_name_hasher_ (void *);
extern void gt_ggc_mx_hash_table_tm_restart_hasher_ (void *);
extern void gt_ggc_mx_vec_mem_addr_template_va_gc_ (void *);
extern void gt_ggc_mx_scev_info_str (void *);
extern void gt_ggc_mx_hash_table_scev_info_hasher_ (void *);
extern void gt_ggc_mx_ssa_operand_memory_d (void *);
extern void gt_ggc_mx_vec_omp_declare_variant_entry_va_gc_ (void *);
extern void gt_ggc_mx_omp_declare_variant_base_entry (void *);
extern void gt_ggc_mx_hash_table_omp_declare_variant_hasher_ (void *);
extern void gt_ggc_mx_hash_table_omp_declare_variant_alt_hasher_ (void *);
extern void gt_ggc_mx_hash_table_dllimport_hasher_ (void *);
extern void gt_ggc_mx_hash_map_char__unsigned_ (void *);
extern void gt_ggc_mx_vec_gimple__va_gc_ (void *);
extern void gt_ggc_mx_int_range_1_ (void *);
extern void gt_ggc_mx_vec_ipa_agg_jf_item_va_gc_ (void *);
extern void gt_ggc_mx_ipa_bits (void *);
extern void gt_ggc_mx_vec_ipa_param_descriptor_va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_bits__va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_vr_va_gc_ (void *);
extern void gt_ggc_mx_ipcp_transformation (void *);
extern void gt_ggc_mx_vec_ipa_jump_func_va_gc_ (void *);
extern void gt_ggc_mx_vec_ipa_polymorphic_call_context_va_gc_ (void *);
extern void gt_ggc_mx_ipa_node_params_t (void *);
extern void gt_ggc_mx_ipa_edge_args_sum_t (void *);
extern void gt_ggc_mx_function_summary_ipcp_transformation__ (void *);
extern void gt_ggc_mx_hash_table_tm_wrapper_hasher_ (void *);
extern void gt_ggc_mx_hash_table_decl_state_hasher_ (void *);
extern void gt_ggc_mx_vec_expr_eval_op_va_gc_ (void *);
extern void gt_ggc_mx_vec_condition_va_gc_ (void *);
extern void gt_ggc_mx_vec_size_time_entry_va_gc_ (void *);
extern void gt_ggc_mx_fast_function_summary_ipa_fn_summary__va_gc_ (void *);
extern void gt_ggc_mx_tree_type_map (void *);
extern void gt_ggc_mx_hash_table_tree_type_map_cache_hasher_ (void *);
extern void gt_ggc_mx_vec_odr_type_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_value_annotation_hasher_ (void *);
extern void gt_ggc_mx_vec_Entity_Id_va_gc_atomic_ (void *);
extern void gt_ggc_mx_tree_entity_vec_map (void *);
extern void gt_ggc_mx_hash_table_dummy_type_hasher_ (void *);
extern void gt_ggc_mx_parm_attr_d (void *);
extern void gt_ggc_mx_vec_parm_attr_va_gc_ (void *);
extern void gt_ggc_mx_stmt_group (void *);
extern void gt_ggc_mx_elab_info (void *);
extern void gt_ggc_mx_range_check_info_d (void *);
extern void gt_ggc_mx_vec_range_check_info_va_gc_ (void *);
extern void gt_ggc_mx_loop_info_d (void *);
extern void gt_ggc_mx_vec_loop_info_va_gc_ (void *);
extern void gt_ggc_mx_gnat_binding_level (void *);
extern void gt_ggc_mx_packable_type_hash (void *);
extern void gt_ggc_mx_hash_table_packable_type_hasher_ (void *);
extern void gt_ggc_mx_pad_type_hash (void *);
extern void gt_ggc_mx_hash_table_pad_type_hasher_ (void *);
extern void gt_ggc_mx_c_label_vars (void *);
extern void gt_ggc_mx_c_binding (void *);
extern void gt_ggc_mx_c_scope (void *);
extern void gt_ggc_mx_c_goto_bindings (void *);
extern void gt_ggc_mx_vec_c_goto_bindings_p_va_gc_ (void *);
extern void gt_ggc_mx_c_inline_static (void *);
extern void gt_ggc_mx_sorted_fields_type (void *);
extern void gt_ggc_mx_vec_const_char_p_va_gc_ (void *);
extern void gt_ggc_mx_vec_tree_gc_vec_va_gc_ (void *);
extern void gt_ggc_mx_align_stack (void *);
extern void gt_ggc_mx_vec_pending_weak_va_gc_ (void *);
extern void gt_ggc_mx_vec_pending_redefinition_va_gc_ (void *);
extern void gt_ggc_mx_opt_stack (void *);
extern void gt_ggc_mx_c_parser (void *);
extern void gt_ggc_mx_vec_c_token_va_gc_ (void *);
extern void gt_ggc_mx_binding_table_s (void *);
extern void gt_ggc_mx_binding_entry_s (void *);
extern void gt_ggc_mx_cxx_binding (void *);
extern void gt_ggc_mx_cp_binding_level (void *);
extern void gt_ggc_mx_vec_cp_class_binding_va_gc_ (void *);
extern void gt_ggc_mx_cp_token_cache (void *);
extern void gt_ggc_mx_vec_deferred_access_check_va_gc_ (void *);
extern void gt_ggc_mx_vec_cxx_saved_binding_va_gc_ (void *);
extern void gt_ggc_mx_saved_scope (void *);
extern void gt_ggc_mx_cxx_int_tree_map (void *);
extern void gt_ggc_mx_named_label_entry (void *);
extern void gt_ggc_mx_hash_table_named_label_hash_ (void *);
extern void gt_ggc_mx_hash_table_cxx_int_tree_map_hasher_ (void *);
extern void gt_ggc_mx_tree_pair_s (void *);
extern void gt_ggc_mx_vec_tree_pair_s_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_named_decl_hash_ (void *);
extern void gt_ggc_mx_tinst_level (void *);
extern void gt_ggc_mx_tree_check (void *);
extern void gt_ggc_mx_vec_cp_token_va_gc_ (void *);
extern void gt_ggc_mx_cp_lexer (void *);
extern void gt_ggc_mx_vec_cp_default_arg_entry_va_gc_ (void *);
extern void gt_ggc_mx_cp_parser_context (void *);
extern void gt_ggc_mx_vec_cp_unparsed_functions_entry_va_gc_ (void *);
extern void gt_ggc_mx_cp_parser (void *);
extern void gt_ggc_mx_hash_map_tree_int_ (void *);
extern void gt_ggc_mx_constexpr_fundef (void *);
extern void gt_ggc_mx_hash_table_constexpr_fundef_hasher_ (void *);
extern void gt_ggc_mx_constexpr_call (void *);
extern void gt_ggc_mx_hash_table_constexpr_call_hasher_ (void *);
extern void gt_ggc_mx_sat_entry (void *);
extern void gt_ggc_mx_hash_table_sat_hasher_ (void *);
extern void gt_ggc_mx_coroutine_info (void *);
extern void gt_ggc_mx_hash_table_coroutine_info_hasher_ (void *);
extern void gt_ggc_mx_source_location_table_entry (void *);
extern void gt_ggc_mx_hash_table_source_location_table_entry_hash_ (void *);
extern void gt_ggc_mx_named_label_use_entry (void *);
extern void gt_ggc_mx_vec_incomplete_var_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_typename_hasher_ (void *);
extern void gt_ggc_mx_hash_table_mangled_decl_hash_ (void *);
extern void gt_ggc_mx_vec_pending_noexcept_va_gc_ (void *);
extern void gt_ggc_mx_vec_tree_int_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_conv_type_hasher_ (void *);
extern void gt_ggc_mx_subsumption_entry (void *);
extern void gt_ggc_mx_hash_table_subsumption_hasher_ (void *);
extern void gt_ggc_mx_pending_template (void *);
extern void gt_ggc_mx_spec_entry (void *);
extern void gt_ggc_mx_hash_table_spec_hasher_ (void *);
extern void gt_ggc_mx_hash_map_tree_tree_pair_p_ (void *);
extern void gt_ggc_mx_vec_tinfo_s_va_gc_ (void *);
extern void gt_ggc_mx_vec_deferred_access_va_gc_ (void *);
extern void gt_ggc_mx_hash_table_cplus_array_hasher_ (void *);
extern void gt_ggc_mx_hash_table_list_hasher_ (void *);
extern void gt_ggc_mx_pending_abstract_type (void *);
extern void gt_ggc_mx_hash_table_abstract_type_hasher_ (void *);
extern void gt_ggc_mx_Statement (void *);
extern void gt_ggc_mx_binding_level (void *);
extern void gt_ggc_mx_d_label_use_entry (void *);
extern void gt_ggc_mx_hash_map_Statement__d_label_entry_ (void *);
extern void gt_ggc_mx_hash_table_module_hasher_ (void *);
extern void gt_ggc_mx_module_htab_entry (void *);
extern void gt_ggc_mx_hash_table_module_decl_hasher_ (void *);
extern void gt_ggc_mx_objc_map_private (void *);
extern void gt_ggc_mx_hashed_entry (void *);
extern void gt_ggc_mx_hashed_attribute (void *);
extern void gt_ggc_mx_imp_entry (void *);
extern void gt_ggc_mx_string_descriptor (void *);
extern void gt_ggc_mx_hash_table_objc_string_hasher_ (void *);
extern void gt_ggc_mx_vec_ident_data_tuple_va_gc_ (void *);
extern void gt_ggc_mx_vec_msgref_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_prot_list_entry_va_gc_ (void *);
extern void gt_ggc_mx_vec_ivarref_entry_va_gc_ (void *);
# 1388 "./gtype-desc.h"
extern void gt_pch_nx_line_maps (void *);
extern void gt_pch_nx_cpp_token (void *);
extern void gt_pch_nx_cpp_macro (void *);
extern void gt_pch_nx_string_concat (void *);
extern void gt_pch_nx_string_concat_db (void *);
extern void gt_pch_nx_hash_map_location_hash_string_concat__ (void *);
extern void gt_pch_nx_bitmap_head (void *);
extern void gt_pch_nx_rtx_def (void *);
extern void gt_pch_nx_rtvec_def (void *);
extern void gt_pch_nx_gimple (void *);
extern void gt_pch_nx_symtab_node (void *);
extern void gt_pch_nx_cgraph_edge (void *);
extern void gt_pch_nx_section (void *);
extern void gt_pch_nx_cl_target_option (void *);
extern void gt_pch_nx_cl_optimization (void *);
extern void gt_pch_nx_edge_def (void *);
extern void gt_pch_nx_basic_block_def (void *);
extern void gt_pch_nx_stack_local_entry (void *);
extern void gt_pch_nx_machine_function (void *);
extern void gt_pch_nx_bitmap_element (void *);
extern void gt_pch_nx_generic_wide_int_wide_int_storage_ (void *);
extern void gt_pch_nx_coverage_data (void *);
extern void gt_pch_nx_mem_attrs (void *);
extern void gt_pch_nx_reg_attrs (void *);
extern void gt_pch_nx_object_block (void *);
extern void gt_pch_nx_vec_rtx_va_gc_ (void *);
extern void gt_pch_nx_real_value (void *);
extern void gt_pch_nx_fixed_value (void *);
extern void gt_pch_nx_constant_descriptor_rtx (void *);
extern void gt_pch_nx_function (void *);
extern void gt_pch_nx_target_rtl (void *);
extern void gt_pch_nx_cgraph_rtl_info (void *);
extern void gt_pch_nx_hash_map_tree_tree_decl_tree_cache_traits_ (void *);
extern void gt_pch_nx_hash_map_tree_tree_type_tree_cache_traits_ (void *);
extern void gt_pch_nx_ptr_info_def (void *);
extern void gt_pch_nx_range_info_def (void *);
extern void gt_pch_nx_die_struct (void *);
extern void gt_pch_nx_vec_constructor_elt_va_gc_ (void *);
extern void gt_pch_nx_vec_tree_va_gc_ (void *);
extern void gt_pch_nx_lang_type (void *);
extern void gt_pch_nx_lang_decl (void *);
extern void gt_pch_nx_tree_statement_list_node (void *);
extern void gt_pch_nx_target_globals (void *);
extern void gt_pch_nx_lang_tree_node (void *);
extern void gt_pch_nx_tree_map (void *);
extern void gt_pch_nx_tree_decl_map (void *);
extern void gt_pch_nx_tree_int_map (void *);
extern void gt_pch_nx_tree_vec_map (void *);
extern void gt_pch_nx_vec_alias_pair_va_gc_ (void *);
extern void gt_pch_nx_libfunc_entry (void *);
extern void gt_pch_nx_hash_table_libfunc_hasher_ (void *);
extern void gt_pch_nx_target_libfuncs (void *);
extern void gt_pch_nx_sequence_stack (void *);
extern void gt_pch_nx_vec_rtx_insn__va_gc_ (void *);
extern void gt_pch_nx_call_site_record_d (void *);
extern void gt_pch_nx_vec_uchar_va_gc_ (void *);
extern void gt_pch_nx_vec_call_site_record_va_gc_ (void *);
extern void gt_pch_nx_gimple_df (void *);
extern void gt_pch_nx_dw_fde_node (void *);
extern void gt_pch_nx_rtx_constant_pool (void *);
extern void gt_pch_nx_frame_space (void *);
extern void gt_pch_nx_vec_callinfo_callee_va_gc_ (void *);
extern void gt_pch_nx_vec_callinfo_dalloc_va_gc_ (void *);
extern void gt_pch_nx_stack_usage (void *);
extern void gt_pch_nx_eh_status (void *);
extern void gt_pch_nx_control_flow_graph (void *);
extern void gt_pch_nx_loops (void *);
extern void gt_pch_nx_language_function (void *);
extern void gt_pch_nx_hash_set_tree_ (void *);
extern void gt_pch_nx_types_used_by_vars_entry (void *);
extern void gt_pch_nx_hash_table_used_type_hasher_ (void *);
extern void gt_pch_nx_nb_iter_bound (void *);
extern void gt_pch_nx_loop_exit (void *);
extern void gt_pch_nx_loop (void *);
extern void gt_pch_nx_control_iv (void *);
extern void gt_pch_nx_vec_loop_p_va_gc_ (void *);
extern void gt_pch_nx_niter_desc (void *);
extern void gt_pch_nx_hash_table_loop_exit_hasher_ (void *);
extern void gt_pch_nx_vec_basic_block_va_gc_ (void *);
extern void gt_pch_nx_rtl_bb_info (void *);
extern void gt_pch_nx_vec_edge_va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_ref_t_va_gc_ (void *);
extern void gt_pch_nx_section_hash_entry (void *);
extern void gt_pch_nx_lto_file_decl_data (void *);
extern void gt_pch_nx_ipa_replace_map (void *);
extern void gt_pch_nx_vec_ipa_replace_map__va_gc_ (void *);
extern void gt_pch_nx_ipa_param_adjustments (void *);
extern void gt_pch_nx_vec_ipa_param_performed_split_va_gc_ (void *);
extern void gt_pch_nx_cgraph_simd_clone (void *);
extern void gt_pch_nx_cgraph_function_version_info (void *);
extern void gt_pch_nx_hash_table_cgraph_edge_hasher_ (void *);
extern void gt_pch_nx_cgraph_indirect_call_info (void *);
extern void gt_pch_nx_asm_node (void *);
extern void gt_pch_nx_symbol_table (void *);
extern void gt_pch_nx_hash_table_section_name_hasher_ (void *);
extern void gt_pch_nx_hash_table_asmname_hasher_ (void *);
extern void gt_pch_nx_hash_map_symtab_node__symbol_priority_map_ (void *);
extern void gt_pch_nx_constant_descriptor_tree (void *);
extern void gt_pch_nx_hash_map_alias_set_hash_int_ (void *);
extern void gt_pch_nx_alias_set_entry (void *);
extern void gt_pch_nx_vec_alias_set_entry__va_gc_ (void *);
extern void gt_pch_nx_hash_table_function_version_hasher_ (void *);
extern void gt_pch_nx_lto_in_decl_state (void *);
extern void gt_pch_nx_hash_table_ipa_bit_ggc_hash_traits_ (void *);
extern void gt_pch_nx_hash_table_ipa_vr_ggc_hash_traits_ (void *);
extern void gt_pch_nx_ipa_node_params (void *);
extern void gt_pch_nx_ipa_edge_args (void *);
extern void gt_pch_nx_ipa_agg_replacement_value (void *);
extern void gt_pch_nx_ipa_fn_summary (void *);
extern void gt_pch_nx_odr_type_d (void *);
extern void gt_pch_nx_vec_ipa_adjusted_param_va_gc_ (void *);
extern void gt_pch_nx_param_access (void *);
extern void gt_pch_nx_vec_param_access__va_gc_ (void *);
extern void gt_pch_nx_isra_func_summary (void *);
extern void gt_pch_nx_vec_isra_param_desc_va_gc_ (void *);
extern void gt_pch_nx_ipa_sra_function_summaries (void *);
extern void gt_pch_nx_typeinfo (void *);
extern void gt_pch_nx_dw_cfi_node (void *);
extern void gt_pch_nx_dw_loc_descr_node (void *);
extern void gt_pch_nx_dw_loc_list_struct (void *);
extern void gt_pch_nx_dw_discr_list_node (void *);
extern void gt_pch_nx_dw_cfa_location (void *);
extern void gt_pch_nx_vec_dw_cfi_ref_va_gc_ (void *);
extern void gt_pch_nx_addr_table_entry (void *);
extern void gt_pch_nx_indirect_string_node (void *);
extern void gt_pch_nx_dwarf_file_data (void *);
extern void gt_pch_nx_hash_map_char__tree_ (void *);
extern void gt_pch_nx_dw_cfi_row (void *);
extern void gt_pch_nx_reg_saved_in_data (void *);
extern void gt_pch_nx_vec_dw_fde_ref_va_gc_ (void *);
extern void gt_pch_nx_hash_table_indirect_string_hasher_ (void *);
extern void gt_pch_nx_comdat_type_node (void *);
extern void gt_pch_nx_vec_dw_line_info_entry_va_gc_ (void *);
extern void gt_pch_nx_dw_line_info_table (void *);
extern void gt_pch_nx_vec_dw_attr_node_va_gc_ (void *);
extern void gt_pch_nx_limbo_die_struct (void *);
extern void gt_pch_nx_hash_table_dwarf_file_hasher_ (void *);
extern void gt_pch_nx_hash_table_decl_die_hasher_ (void *);
extern void gt_pch_nx_vec_dw_die_ref_va_gc_ (void *);
extern void gt_pch_nx_variable_value_struct (void *);
extern void gt_pch_nx_hash_table_variable_value_hasher_ (void *);
extern void gt_pch_nx_hash_table_block_die_hasher_ (void *);
extern void gt_pch_nx_var_loc_node (void *);
extern void gt_pch_nx_var_loc_list_def (void *);
extern void gt_pch_nx_call_arg_loc_node (void *);
extern void gt_pch_nx_hash_table_decl_loc_hasher_ (void *);
extern void gt_pch_nx_cached_dw_loc_list_def (void *);
extern void gt_pch_nx_hash_table_dw_loc_list_hasher_ (void *);
extern void gt_pch_nx_vec_dw_line_info_table__va_gc_ (void *);
extern void gt_pch_nx_vec_pubname_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_macinfo_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_dw_ranges_va_gc_ (void *);
extern void gt_pch_nx_vec_dw_ranges_by_label_va_gc_ (void *);
extern void gt_pch_nx_vec_die_arg_entry_va_gc_ (void *);
extern void gt_pch_nx_hash_table_addr_hasher_ (void *);
extern void gt_pch_nx_hash_map_tree_sym_off_pair_ (void *);
extern void gt_pch_nx_inline_entry_data (void *);
extern void gt_pch_nx_hash_table_inline_entry_data_hasher_ (void *);
extern void gt_pch_nx_temp_slot (void *);
extern void gt_pch_nx_initial_value_struct (void *);
extern void gt_pch_nx_vec_temp_slot_p_va_gc_ (void *);
extern void gt_pch_nx_hash_table_const_int_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_wide_int_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_poly_int_hasher_ (void *);
extern void gt_pch_nx_hash_table_reg_attr_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_double_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_fixed_hasher_ (void *);
extern void gt_pch_nx_eh_region_d (void *);
extern void gt_pch_nx_eh_landing_pad_d (void *);
extern void gt_pch_nx_eh_catch_d (void *);
extern void gt_pch_nx_vec_eh_region_va_gc_ (void *);
extern void gt_pch_nx_vec_eh_landing_pad_va_gc_ (void *);
extern void gt_pch_nx_hash_map_gimple__int_ (void *);
extern void gt_pch_nx_hash_table_insn_cache_hasher_ (void *);
extern void gt_pch_nx_temp_slot_address_entry (void *);
extern void gt_pch_nx_hash_table_temp_address_hasher_ (void *);
extern void gt_pch_nx_hash_map_tree_hash_tree_ (void *);
extern void gt_pch_nx_test_struct (void *);
extern void gt_pch_nx_test_of_length (void *);
extern void gt_pch_nx_test_other (void *);
extern void gt_pch_nx_test_of_union (void *);
extern void gt_pch_nx_example_base (void *);
extern void gt_pch_nx_test_node (void *);
extern void gt_pch_nx_user_struct (void *);
extern void gt_pch_nx_hash_table_libfunc_decl_hasher_ (void *);
extern void gt_pch_nx_string_pool_data (void *);
extern void gt_pch_nx_type_hash (void *);
extern void gt_pch_nx_hash_table_type_cache_hasher_ (void *);
extern void gt_pch_nx_hash_table_int_cst_hasher_ (void *);
extern void gt_pch_nx_hash_table_poly_int_cst_hasher_ (void *);
extern void gt_pch_nx_hash_table_cl_option_hasher_ (void *);
extern void gt_pch_nx_hash_table_tree_decl_map_cache_hasher_ (void *);
extern void gt_pch_nx_hash_table_tree_vec_map_cache_hasher_ (void *);
extern void gt_pch_nx_hash_table_section_hasher_ (void *);
extern void gt_pch_nx_hash_table_object_block_hasher_ (void *);
extern void gt_pch_nx_hash_table_tree_descriptor_hasher_ (void *);
extern void gt_pch_nx_hash_table_const_rtx_desc_hasher_ (void *);
extern void gt_pch_nx_hash_table_tm_clone_hasher_ (void *);
extern void gt_pch_nx_tm_restart_node (void *);
extern void gt_pch_nx_hash_map_tree_tree_ (void *);
extern void gt_pch_nx_hash_table_ssa_name_hasher_ (void *);
extern void gt_pch_nx_hash_table_tm_restart_hasher_ (void *);
extern void gt_pch_nx_vec_mem_addr_template_va_gc_ (void *);
extern void gt_pch_nx_scev_info_str (void *);
extern void gt_pch_nx_hash_table_scev_info_hasher_ (void *);
extern void gt_pch_nx_ssa_operand_memory_d (void *);
extern void gt_pch_nx_vec_omp_declare_variant_entry_va_gc_ (void *);
extern void gt_pch_nx_omp_declare_variant_base_entry (void *);
extern void gt_pch_nx_hash_table_omp_declare_variant_hasher_ (void *);
extern void gt_pch_nx_hash_table_omp_declare_variant_alt_hasher_ (void *);
extern void gt_pch_nx_hash_table_dllimport_hasher_ (void *);
extern void gt_pch_nx_hash_map_char__unsigned_ (void *);
extern void gt_pch_nx_vec_gimple__va_gc_ (void *);
extern void gt_pch_nx_int_range_1_ (void *);
extern void gt_pch_nx_vec_ipa_agg_jf_item_va_gc_ (void *);
extern void gt_pch_nx_ipa_bits (void *);
extern void gt_pch_nx_vec_ipa_param_descriptor_va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_bits__va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_vr_va_gc_ (void *);
extern void gt_pch_nx_ipcp_transformation (void *);
extern void gt_pch_nx_vec_ipa_jump_func_va_gc_ (void *);
extern void gt_pch_nx_vec_ipa_polymorphic_call_context_va_gc_ (void *);
extern void gt_pch_nx_ipa_node_params_t (void *);
extern void gt_pch_nx_ipa_edge_args_sum_t (void *);
extern void gt_pch_nx_function_summary_ipcp_transformation__ (void *);
extern void gt_pch_nx_hash_table_tm_wrapper_hasher_ (void *);
extern void gt_pch_nx_hash_table_decl_state_hasher_ (void *);
extern void gt_pch_nx_vec_expr_eval_op_va_gc_ (void *);
extern void gt_pch_nx_vec_condition_va_gc_ (void *);
extern void gt_pch_nx_vec_size_time_entry_va_gc_ (void *);
extern void gt_pch_nx_fast_function_summary_ipa_fn_summary__va_gc_ (void *);
extern void gt_pch_nx_tree_type_map (void *);
extern void gt_pch_nx_hash_table_tree_type_map_cache_hasher_ (void *);
extern void gt_pch_nx_vec_odr_type_va_gc_ (void *);
extern void gt_pch_nx_hash_table_value_annotation_hasher_ (void *);
extern void gt_pch_nx_vec_Entity_Id_va_gc_atomic_ (void *);
extern void gt_pch_nx_tree_entity_vec_map (void *);
extern void gt_pch_nx_hash_table_dummy_type_hasher_ (void *);
extern void gt_pch_nx_parm_attr_d (void *);
extern void gt_pch_nx_vec_parm_attr_va_gc_ (void *);
extern void gt_pch_nx_stmt_group (void *);
extern void gt_pch_nx_elab_info (void *);
extern void gt_pch_nx_range_check_info_d (void *);
extern void gt_pch_nx_vec_range_check_info_va_gc_ (void *);
extern void gt_pch_nx_loop_info_d (void *);
extern void gt_pch_nx_vec_loop_info_va_gc_ (void *);
extern void gt_pch_nx_gnat_binding_level (void *);
extern void gt_pch_nx_packable_type_hash (void *);
extern void gt_pch_nx_hash_table_packable_type_hasher_ (void *);
extern void gt_pch_nx_pad_type_hash (void *);
extern void gt_pch_nx_hash_table_pad_type_hasher_ (void *);
extern void gt_pch_nx_c_label_vars (void *);
extern void gt_pch_nx_c_binding (void *);
extern void gt_pch_nx_c_scope (void *);
extern void gt_pch_nx_c_goto_bindings (void *);
extern void gt_pch_nx_vec_c_goto_bindings_p_va_gc_ (void *);
extern void gt_pch_nx_c_inline_static (void *);
extern void gt_pch_nx_sorted_fields_type (void *);
extern void gt_pch_nx_vec_const_char_p_va_gc_ (void *);
extern void gt_pch_nx_vec_tree_gc_vec_va_gc_ (void *);
extern void gt_pch_nx_align_stack (void *);
extern void gt_pch_nx_vec_pending_weak_va_gc_ (void *);
extern void gt_pch_nx_vec_pending_redefinition_va_gc_ (void *);
extern void gt_pch_nx_opt_stack (void *);
extern void gt_pch_nx_c_parser (void *);
extern void gt_pch_nx_vec_c_token_va_gc_ (void *);
extern void gt_pch_nx_binding_table_s (void *);
extern void gt_pch_nx_binding_entry_s (void *);
extern void gt_pch_nx_cxx_binding (void *);
extern void gt_pch_nx_cp_binding_level (void *);
extern void gt_pch_nx_vec_cp_class_binding_va_gc_ (void *);
extern void gt_pch_nx_cp_token_cache (void *);
extern void gt_pch_nx_vec_deferred_access_check_va_gc_ (void *);
extern void gt_pch_nx_vec_cxx_saved_binding_va_gc_ (void *);
extern void gt_pch_nx_saved_scope (void *);
extern void gt_pch_nx_cxx_int_tree_map (void *);
extern void gt_pch_nx_named_label_entry (void *);
extern void gt_pch_nx_hash_table_named_label_hash_ (void *);
extern void gt_pch_nx_hash_table_cxx_int_tree_map_hasher_ (void *);
extern void gt_pch_nx_tree_pair_s (void *);
extern void gt_pch_nx_vec_tree_pair_s_va_gc_ (void *);
extern void gt_pch_nx_hash_table_named_decl_hash_ (void *);
extern void gt_pch_nx_tinst_level (void *);
extern void gt_pch_nx_tree_check (void *);
extern void gt_pch_nx_vec_cp_token_va_gc_ (void *);
extern void gt_pch_nx_cp_lexer (void *);
extern void gt_pch_nx_vec_cp_default_arg_entry_va_gc_ (void *);
extern void gt_pch_nx_cp_parser_context (void *);
extern void gt_pch_nx_vec_cp_unparsed_functions_entry_va_gc_ (void *);
extern void gt_pch_nx_cp_parser (void *);
extern void gt_pch_nx_hash_map_tree_int_ (void *);
extern void gt_pch_nx_constexpr_fundef (void *);
extern void gt_pch_nx_hash_table_constexpr_fundef_hasher_ (void *);
extern void gt_pch_nx_constexpr_call (void *);
extern void gt_pch_nx_hash_table_constexpr_call_hasher_ (void *);
extern void gt_pch_nx_sat_entry (void *);
extern void gt_pch_nx_hash_table_sat_hasher_ (void *);
extern void gt_pch_nx_coroutine_info (void *);
extern void gt_pch_nx_hash_table_coroutine_info_hasher_ (void *);
extern void gt_pch_nx_source_location_table_entry (void *);
extern void gt_pch_nx_hash_table_source_location_table_entry_hash_ (void *);
extern void gt_pch_nx_named_label_use_entry (void *);
extern void gt_pch_nx_vec_incomplete_var_va_gc_ (void *);
extern void gt_pch_nx_hash_table_typename_hasher_ (void *);
extern void gt_pch_nx_hash_table_mangled_decl_hash_ (void *);
extern void gt_pch_nx_vec_pending_noexcept_va_gc_ (void *);
extern void gt_pch_nx_vec_tree_int_va_gc_ (void *);
extern void gt_pch_nx_hash_table_conv_type_hasher_ (void *);
extern void gt_pch_nx_subsumption_entry (void *);
extern void gt_pch_nx_hash_table_subsumption_hasher_ (void *);
extern void gt_pch_nx_pending_template (void *);
extern void gt_pch_nx_spec_entry (void *);
extern void gt_pch_nx_hash_table_spec_hasher_ (void *);
extern void gt_pch_nx_hash_map_tree_tree_pair_p_ (void *);
extern void gt_pch_nx_vec_tinfo_s_va_gc_ (void *);
extern void gt_pch_nx_vec_deferred_access_va_gc_ (void *);
extern void gt_pch_nx_hash_table_cplus_array_hasher_ (void *);
extern void gt_pch_nx_hash_table_list_hasher_ (void *);
extern void gt_pch_nx_pending_abstract_type (void *);
extern void gt_pch_nx_hash_table_abstract_type_hasher_ (void *);
extern void gt_pch_nx_Statement (void *);
extern void gt_pch_nx_binding_level (void *);
extern void gt_pch_nx_d_label_use_entry (void *);
extern void gt_pch_nx_hash_map_Statement__d_label_entry_ (void *);
extern void gt_pch_nx_hash_table_module_hasher_ (void *);
extern void gt_pch_nx_module_htab_entry (void *);
extern void gt_pch_nx_hash_table_module_decl_hasher_ (void *);
extern void gt_pch_nx_objc_map_private (void *);
extern void gt_pch_nx_hashed_entry (void *);
extern void gt_pch_nx_hashed_attribute (void *);
extern void gt_pch_nx_imp_entry (void *);
extern void gt_pch_nx_string_descriptor (void *);
extern void gt_pch_nx_hash_table_objc_string_hasher_ (void *);
extern void gt_pch_nx_vec_ident_data_tuple_va_gc_ (void *);
extern void gt_pch_nx_vec_msgref_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_prot_list_entry_va_gc_ (void *);
extern void gt_pch_nx_vec_ivarref_entry_va_gc_ (void *);
extern void gt_pch_p_9line_maps
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cpp_token
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cpp_macro
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13string_concat
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16string_concat_db
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_map_location_hash_string_concat__
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11bitmap_head
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9rtvec_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11symtab_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11symtab_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11symtab_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11cgraph_edge
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7section
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16cl_target_option
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15cl_optimization
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8edge_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15basic_block_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17stack_local_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16machine_function
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14bitmap_element
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34generic_wide_int_wide_int_storage_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13coverage_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9mem_attrs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9reg_attrs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12object_block
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14vec_rtx_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10real_value
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11fixed_value
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23constant_descriptor_rtx
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8function
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10target_rtl
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15cgraph_rtl_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_map_tree_tree_decl_tree_cache_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_map_tree_tree_type_tree_cache_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12ptr_info_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14range_info_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10die_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_constructor_elt_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15vec_tree_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9lang_type
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9lang_decl
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24tree_statement_list_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14target_globals
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14lang_tree_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8tree_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13tree_decl_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12tree_int_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12tree_vec_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_alias_pair_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13libfunc_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_libfunc_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15target_libfuncs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14sequence_stack
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_rtx_insn__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18call_site_record_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16vec_uchar_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_call_site_record_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9gimple_df
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11dw_fde_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17rtx_constant_pool
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11frame_space
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_callinfo_callee_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_callinfo_dalloc_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11stack_usage
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9eh_status
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18control_flow_graph
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_5loops
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17language_function
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14hash_set_tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24types_used_by_vars_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_used_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13nb_iter_bound
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9loop_exit
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_4loop
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10control_iv
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17vec_loop_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10niter_desc
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_loop_exit_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_basic_block_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11rtl_bb_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15vec_edge_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_ipa_ref_t_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18section_hash_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18lto_file_decl_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15ipa_replace_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_ipa_replace_map__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21ipa_param_adjustments
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_36vec_ipa_param_performed_split_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17cgraph_simd_clone
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28cgraph_function_version_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_cgraph_edge_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25cgraph_indirect_call_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8asm_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12symbol_table
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_section_name_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_asmname_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_map_symtab_node__symbol_priority_map_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24constant_descriptor_tree
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_map_alias_set_hash_int_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15alias_set_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_alias_set_entry__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_function_version_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17lto_in_decl_state
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_ipa_bit_ggc_hash_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_table_ipa_vr_ggc_hash_traits_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15ipa_node_params
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13ipa_edge_args
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25ipa_agg_replacement_value
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14ipa_fn_summary
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10odr_type_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29vec_ipa_adjusted_param_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12param_access
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_param_access__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17isra_func_summary
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_isra_param_desc_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26ipa_sra_function_summaries
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8typeinfo
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11dw_cfi_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17dw_loc_descr_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18dw_loc_list_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18dw_discr_list_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15dw_cfa_location
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_dw_cfi_ref_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16addr_table_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20indirect_string_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15dwarf_file_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20hash_map_char__tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10dw_cfi_row
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17reg_saved_in_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_dw_fde_ref_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_table_indirect_string_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16comdat_type_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29vec_dw_line_info_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18dw_line_info_table
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_dw_attr_node_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16limbo_die_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_dwarf_file_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_decl_die_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21vec_dw_die_ref_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21variable_value_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_variable_value_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_block_die_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12var_loc_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16var_loc_list_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17call_arg_loc_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_decl_loc_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22cached_dw_loc_list_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_dw_loc_list_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30vec_dw_line_info_table__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_pubname_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_macinfo_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_dw_ranges_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29vec_dw_ranges_by_label_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_die_arg_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23hash_table_addr_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_map_tree_sym_off_pair_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17inline_entry_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_36hash_table_inline_entry_data_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9temp_slot
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20initial_value_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_temp_slot_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_const_int_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_const_wide_int_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_const_poly_int_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_reg_attr_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_const_double_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_const_fixed_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11eh_region_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16eh_landing_pad_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10eh_catch_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_eh_region_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25vec_eh_landing_pad_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21hash_map_gimple__int_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_insn_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23temp_slot_address_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_temp_address_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24hash_map_tree_hash_tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11test_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14test_of_length
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10test_other
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13test_of_union
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12example_base
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12example_base
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12example_base
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9test_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11user_struct
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_libfunc_decl_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16string_pool_data
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9type_hash
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_type_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_int_cst_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_poly_int_cst_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_cl_option_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_table_tree_decl_map_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_37hash_table_tree_vec_map_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_table_section_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31hash_table_object_block_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_table_tree_descriptor_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_const_rtx_desc_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_tm_clone_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6gimple
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15tm_restart_node
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19hash_map_tree_tree_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_ssa_name_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_tm_restart_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28vec_mem_addr_template_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13scev_info_str
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_scev_info_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20ssa_operand_memory_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_36vec_omp_declare_variant_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30omp_declare_variant_base_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_table_omp_declare_variant_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_42hash_table_omp_declare_variant_alt_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_dllimport_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24hash_map_char__unsigned_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18vec_gimple__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12int_range_1_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_ipa_agg_jf_item_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8ipa_bits
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31vec_ipa_param_descriptor_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_ipa_bits__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17vec_ipa_vr_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19ipcp_transformation
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_ipa_jump_func_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_39vec_ipa_polymorphic_call_context_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17ipa_node_params_t
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19ipa_edge_args_sum_t
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38function_summary_ipcp_transformation__
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_tm_wrapper_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_decl_state_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_expr_eval_op_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_condition_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_size_time_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_44fast_function_summary_ipa_fn_summary__va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13tree_type_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38hash_table_tree_type_map_cache_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19vec_odr_type_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_value_annotation_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_Entity_Id_va_gc_atomic_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19tree_entity_vec_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_dummy_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11parm_attr_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_parm_attr_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10stmt_group
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9elab_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18range_check_info_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_range_check_info_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11loop_info_d
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_20vec_loop_info_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18gnat_binding_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18packable_type_hash
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_32hash_table_packable_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13pad_type_hash
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_pad_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12c_label_vars
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9c_binding
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7c_scope
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15c_goto_bindings
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28vec_c_goto_bindings_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15c_inline_static
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18sorted_fields_type
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_const_char_p_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_tree_gc_vec_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11align_stack
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_pending_weak_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31vec_pending_redefinition_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9opt_stack
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8c_parser
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18vec_c_token_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15binding_table_s
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_15binding_entry_s
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11cxx_binding
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16cp_binding_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_cp_class_binding_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14cp_token_cache
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_32vec_deferred_access_check_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28vec_cxx_saved_binding_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11saved_scope
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16cxx_int_tree_map
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17named_label_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_named_label_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_cxx_int_tree_map_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11tree_pair_s
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22vec_tree_pair_s_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_named_decl_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_11tinst_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10tree_check
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19vec_cp_token_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8cp_lexer
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_31vec_cp_default_arg_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17cp_parser_context
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_38vec_cp_unparsed_functions_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cp_parser
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18hash_map_tree_int_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16constexpr_fundef
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_35hash_table_constexpr_fundef_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14constexpr_call
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_constexpr_call_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9sat_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_22hash_table_sat_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_14coroutine_info
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_33hash_table_coroutine_info_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27source_location_table_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_44hash_table_source_location_table_entry_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21named_label_use_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25vec_incomplete_var_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27hash_table_typename_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_29hash_table_mangled_decl_hash_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_pending_noexcept_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_19vec_tree_int_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_28hash_table_conv_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17subsumption_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_subsumption_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16pending_template
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_10spec_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23hash_table_spec_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26hash_map_tree_tree_pair_p_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_18vec_tinfo_s_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_deferred_access_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_cplus_array_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23hash_table_list_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_21pending_abstract_type
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_32hash_table_abstract_type_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9Statement
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_13binding_level
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17d_label_use_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_34hash_map_Statement__d_label_entry_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_25hash_table_module_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17module_htab_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_module_decl_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16objc_map_private
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_12hashed_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_16hashed_attribute
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9imp_entry
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_17string_descriptor
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_30hash_table_objc_string_hasher_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_27vec_ident_data_tuple_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_23vec_msgref_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_26vec_prot_list_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_24vec_ivarref_entry_va_gc_
(void *, void *, gt_pointer_operator, void *);
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h" 2
typedef void (*gt_note_pointers) (void *, void *, gt_pointer_operator,
void *);
typedef void (*gt_handle_reorder) (void *, void *, gt_pointer_operator,
void *);
extern int gt_pch_note_object (void *, void *, gt_note_pointers);
extern void gt_pch_note_reorder (void *, void *, gt_handle_reorder);
extern void gt_clear_caches ();
typedef void (*gt_pointer_walker) (void *);
struct ggc_root_tab {
void *base;
size_t nelt;
size_t stride;
gt_pointer_walker cb;
gt_pointer_walker pchw;
};
extern const struct ggc_root_tab * const gt_ggc_rtab[];
extern const struct ggc_root_tab * const gt_ggc_deletable_rtab[];
extern const struct ggc_root_tab * const gt_pch_scalar_rtab[];
# 91 "/home/giulianob/gcc_git_gnu/gcc/gcc/ggc.h"
extern int ggc_set_mark (const void *);
extern int ggc_marked_p (const void *);
extern void gt_pch_n_S (const void *);
extern void gt_ggc_m_S (const void *);
extern void init_stringpool (void);
extern void init_ggc (void);
extern bool ggc_protect_identifiers;
extern void gt_pch_save (FILE *f);
extern void *ggc_internal_alloc (size_t, void (*)(void *), size_t,
size_t )
__attribute__ ((__malloc__));
inline void *
ggc_internal_alloc (size_t s )
{
return ggc_internal_alloc (s, nullptr, 0, 1 );
}
extern size_t ggc_round_alloc_size (size_t requested_size);
extern void *ggc_internal_cleared_alloc (size_t, void (*)(void *),
size_t, size_t
) __attribute__ ((__malloc__));
inline void *
ggc_internal_cleared_alloc (size_t s )
{
return ggc_internal_cleared_alloc (s, nullptr, 0, 1 );
}
extern void *ggc_realloc (void *, size_t );
extern void ggc_free (void *);
extern void dump_ggc_loc_statistics ();
template<typename T>
void
finalize (void *p)
{
static_cast<T *> (p)->~T ();
}
template<typename T>
inline bool
need_finalization_p ()
{
return !__has_trivial_destructor (T);
}
template<typename T>
inline T *
ggc_alloc ()
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_alloc (sizeof (T), finalize<T>, 0, 1
));
else
return static_cast<T *> (ggc_internal_alloc (sizeof (T), nullptr, 0, 1
));
}
template<typename T>
inline T *
ggc_alloc_no_dtor ()
{
return static_cast<T *> (ggc_internal_alloc (sizeof (T), nullptr, 0, 1
));
}
template<typename T>
inline T *
ggc_cleared_alloc ()
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_cleared_alloc (sizeof (T),
finalize<T>, 0, 1
));
else
return static_cast<T *> (ggc_internal_cleared_alloc (sizeof (T), nullptr, 0, 1
));
}
template<typename T>
inline T *
ggc_vec_alloc (size_t c )
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_alloc (c * sizeof (T), finalize<T>,
sizeof (T), c ));
else
return static_cast<T *> (ggc_internal_alloc (c * sizeof (T), nullptr, 0, 0
));
}
template<typename T>
inline T *
ggc_cleared_vec_alloc (size_t c )
{
if (need_finalization_p<T> ())
return static_cast<T *> (ggc_internal_cleared_alloc (c * sizeof (T),
finalize<T>,
sizeof (T), c
));
else
return static_cast<T *> (ggc_internal_cleared_alloc (c * sizeof (T), nullptr,
0, 0 ));
}
inline void *
ggc_alloc_atomic (size_t s )
{
return ggc_internal_alloc (s );
}
template <typename T>
inline void
ggc_delete (T *ptr)
{
ptr->~T ();
ggc_free (ptr);
}
extern const char *ggc_alloc_string (const char *contents, int length
);
extern void ggc_collect (void);
extern void ggc_trim (void);
extern void ggc_grow (void);
extern void ggc_register_root_tab (const struct ggc_root_tab *);
extern void gt_pch_restore (FILE *f);
extern void ggc_print_statistics (void);
extern void stringpool_statistics (void);
extern void init_ggc_heuristics (void);
extern void report_heap_memory_use (void);
inline struct rtx_def *
ggc_alloc_rtx_def_stat (size_t s )
{
return (struct rtx_def *) ggc_internal_alloc (s );
}
inline union tree_node *
ggc_alloc_tree_node_stat (size_t s )
{
return (union tree_node *) ggc_internal_alloc (s );
}
inline union tree_node *
ggc_alloc_cleared_tree_node_stat (size_t s )
{
return (union tree_node *) ggc_internal_cleared_alloc (s );
}
inline gimple *
ggc_alloc_cleared_gimple_statement_stat (size_t s )
{
return (gimple *) ggc_internal_cleared_alloc (s );
}
inline void
gt_ggc_mx (const char *s)
{
((const_cast<char *> (s)) != nullptr && ((void *) (const_cast<char *> (s))) != (void *) 1 && ! ggc_set_mark (const_cast<char *> (s)));
}
inline void
gt_pch_nx (const char *)
{
}
inline void
gt_ggc_mx (int)
{
}
inline void
gt_pch_nx (int)
{
}
inline void
gt_pch_nx (unsigned int)
{
}
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 1
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
extern void ggc_free (void *);
extern size_t ggc_round_alloc_size (size_t requested_size);
extern void *ggc_realloc (void *, size_t );
# 183 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
extern void dump_vec_loc_statistics (void);
extern htab_t vec_mem_usage_hash;
struct vec_prefix
{
void register_overhead (void *, size_t, size_t );
void release_overhead (void *, size_t, size_t, bool );
static unsigned calculate_allocation (vec_prefix *, unsigned, bool);
static unsigned calculate_allocation_1 (unsigned, unsigned);
template <typename, typename, typename> friend struct vec;
friend struct va_gc;
friend struct va_gc_atomic;
friend struct va_heap;
unsigned m_alloc : 31;
unsigned m_using_auto_storage : 1;
unsigned m_num;
};
inline unsigned
vec_prefix::calculate_allocation (vec_prefix *pfx, unsigned reserve,
bool exact)
{
if (exact)
return (pfx ? pfx->m_num : 0) + reserve;
else if (!pfx)
return ((4) > (reserve) ? (4) : (reserve));
return calculate_allocation_1 (pfx->m_alloc, pfx->m_num + reserve);
}
template<typename, typename, typename> struct vec;
struct vl_embed { };
struct vl_ptr { };
# 254 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
struct va_heap
{
typedef vl_ptr default_layout;
template<typename T>
static void reserve (vec<T, va_heap, vl_embed> *&, unsigned, bool
);
template<typename T>
static void release (vec<T, va_heap, vl_embed> *&);
};
template<typename T>
inline void
va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
)
{
size_t elt_size = sizeof (T);
unsigned alloc
= vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
((void)(!(alloc) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 282, __FUNCTION__), 0 : 0));
if (0 && v)
v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
v->allocated (), false);
size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
unsigned nelem = v ? v->length () : 0;
v = static_cast <vec<T, va_heap, vl_embed> *> (xrealloc (v, size));
v->embedded_init (alloc, nelem);
if (0)
v->m_vecpfx.register_overhead (v, alloc, elt_size );
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
template<typename T>
void
va_heap::release (vec<T, va_heap, vl_embed> *&v)
{
size_t elt_size = sizeof (T);
if (v == nullptr)
return;
if (0)
v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
v->allocated (), true);
::free (v);
v = nullptr;
}
#pragma GCC diagnostic pop
struct va_gc
{
typedef vl_embed default_layout;
template<typename T, typename A>
static void reserve (vec<T, A, vl_embed> *&, unsigned, bool
);
template<typename T, typename A>
static void release (vec<T, A, vl_embed> *&v);
};
template<typename T, typename A>
inline void
va_gc::release (vec<T, A, vl_embed> *&v)
{
if (v)
::ggc_free (v);
v = nullptr;
}
template<typename T, typename A>
void
va_gc::reserve (vec<T, A, vl_embed> *&v, unsigned reserve, bool exact
)
{
unsigned alloc
= vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
if (!alloc)
{
::ggc_free (v);
v = nullptr;
return;
}
size_t size = vec<T, A, vl_embed>::embedded_size (alloc);
size = ::ggc_round_alloc_size (size);
size_t vec_offset = sizeof (vec_prefix);
size_t elt_size = sizeof (T);
alloc = (size - vec_offset) / elt_size;
size = vec_offset + alloc * elt_size;
unsigned nelem = v ? v->length () : 0;
v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc (v, size
));
v->embedded_init (alloc, nelem);
}
struct va_gc_atomic : va_gc
{
};
# 415 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T,
typename A = va_heap,
typename L = typename A::default_layout>
struct vec
{
};
# 433 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
void
debug_helper (vec<T> &ref)
{
unsigned i;
for (i = 0; i < ref.length (); ++i)
{
fprintf (
# 440 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 440 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
, "[%d] = ", i);
debug_slim (ref[i]);
fputc ('\n',
# 442 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 442 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
);
}
}
template<typename T>
void
debug_helper (vec<T, va_gc> &ref)
{
unsigned i;
for (i = 0; i < ref.length (); ++i)
{
fprintf (
# 458 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 458 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
, "[%d] = ", i);
debug_slim (ref[i]);
fputc ('\n',
# 460 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
stderr
# 460 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
);
}
}
# 501 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template <typename T>
inline void
vec_default_construct (T *dst, unsigned n)
{
# 520 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
for ( ; n; ++dst, --n)
::new (static_cast<void*>(dst)) T ();
}
template <typename T>
inline void
vec_copy_construct (T *dst, const T *src, unsigned n)
{
for ( ; n; ++dst, ++src, --n)
::new (static_cast<void*>(dst)) T (*src);
}
struct vnull
{
template <typename T, typename A, typename L>
constexpr operator vec<T, A, L> () { return vec<T, A, L>(); }
};
extern vnull vNULL;
# 574 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
struct vec<T, A, vl_embed>
{
public:
unsigned allocated (void) const { return m_vecpfx.m_alloc; }
unsigned length (void) const { return m_vecpfx.m_num; }
bool is_empty (void) const { return m_vecpfx.m_num == 0; }
T *address (void) { return m_vecdata; }
const T *address (void) const { return m_vecdata; }
T *begin () { return address (); }
const T *begin () const { return address (); }
T *end () { return address () + length (); }
const T *end () const { return address () + length (); }
const T &operator[] (unsigned) const;
T &operator[] (unsigned);
T &last (void);
bool space (unsigned) const;
bool iterate (unsigned, T *) const;
bool iterate (unsigned, T **) const;
vec *copy () const;
void splice (const vec &);
void splice (const vec *src);
T *quick_push (const T &);
T &pop (void);
void truncate (unsigned);
void quick_insert (unsigned, const T &);
void ordered_remove (unsigned);
void unordered_remove (unsigned);
void block_remove (unsigned, unsigned);
void qsort (int (*) (const void *, const void *));
void sort (int (*) (const void *, const void *, void *), void *);
T *bsearch (const void *key, int (*compar)(const void *, const void *));
T *bsearch (const void *key,
int (*compar)(const void *, const void *, void *), void *);
unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
bool contains (const T &search) const;
static size_t embedded_size (unsigned);
void embedded_init (unsigned, unsigned = 0, unsigned = 0);
void quick_grow (unsigned len);
void quick_grow_cleared (unsigned len);
template <typename, typename, typename> friend struct vec;
friend struct va_gc;
friend struct va_gc_atomic;
friend struct va_heap;
vec_prefix m_vecpfx;
T m_vecdata[1];
};
# 645 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec_safe_space (const vec<T, A, vl_embed> *v, unsigned nelems)
{
return v ? v->space (nelems) : nelems == 0;
}
template<typename T, typename A>
inline unsigned
vec_safe_length (const vec<T, A, vl_embed> *v)
{
return v ? v->length () : 0;
}
template<typename T, typename A>
inline T *
vec_safe_address (vec<T, A, vl_embed> *v)
{
return v ? v->address () : nullptr;
}
template<typename T, typename A>
inline bool
vec_safe_is_empty (vec<T, A, vl_embed> *v)
{
return v ? v->is_empty () : true;
}
template<typename T, typename A>
inline bool
vec_safe_reserve (vec<T, A, vl_embed> *&v, unsigned nelems, bool exact = false
)
{
bool extend = nelems ? !vec_safe_space (v, nelems) : false;
if (extend)
A::reserve (v, nelems, exact );
return extend;
}
template<typename T, typename A>
inline bool
vec_safe_reserve_exact (vec<T, A, vl_embed> *&v, unsigned nelems
)
{
return vec_safe_reserve (v, nelems, true );
}
template<typename T, typename A>
inline void
vec_alloc (vec<T, A, vl_embed> *&v, unsigned nelems )
{
v = nullptr;
vec_safe_reserve (v, nelems, false );
}
template<typename T, typename A>
inline void
vec_free (vec<T, A, vl_embed> *&v)
{
A::release (v);
}
template<typename T, typename A>
inline void
vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len )
{
unsigned oldlen = vec_safe_length (v);
((void)(!(len >= oldlen) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 729, __FUNCTION__), 0 : 0));
vec_safe_reserve_exact (v, len - oldlen );
v->quick_grow (len);
}
template<typename T, typename A>
inline void
vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len )
{
unsigned oldlen = vec_safe_length (v);
vec_safe_grow (v, len );
vec_default_construct (v->address () + oldlen, len - oldlen);
}
template<typename T>
inline void
vec_safe_grow_cleared (vec<T, va_heap, vl_ptr> *&v,
unsigned len )
{
v->safe_grow_cleared (len );
}
template<typename T>
inline bool
vec_safe_reserve (vec<T, va_heap, vl_ptr> *&v, unsigned nelems, bool exact = false
)
{
return v->reserve (nelems, exact);
}
template<typename T, typename A>
inline bool
vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T **ptr)
{
if (v)
return v->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
template<typename T, typename A>
inline bool
vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T *ptr)
{
if (v)
return v->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
template<typename T, typename A>
inline T *
vec_safe_push (vec<T, A, vl_embed> *&v, const T &obj )
{
vec_safe_reserve (v, 1, false );
return v->quick_push (obj);
}
template<typename T, typename A>
inline void
vec_safe_insert (vec<T, A, vl_embed> *&v, unsigned ix, const T &obj
)
{
vec_safe_reserve (v, 1, false );
v->quick_insert (ix, obj);
}
template<typename T, typename A>
inline void
vec_safe_truncate (vec<T, A, vl_embed> *v, unsigned size)
{
if (v)
v->truncate (size);
}
template<typename T, typename A>
inline vec<T, A, vl_embed> *
vec_safe_copy (vec<T, A, vl_embed> *src )
{
return src ? src->copy () : nullptr;
}
template<typename T, typename A>
inline void
vec_safe_splice (vec<T, A, vl_embed> *&dst, const vec<T, A, vl_embed> *src
)
{
unsigned src_len = vec_safe_length (src);
if (src_len)
{
vec_safe_reserve_exact (dst, vec_safe_length (dst) + src_len
);
dst->splice (*src);
}
}
template<typename T, typename A>
inline bool
vec_safe_contains (vec<T, A, vl_embed> *v, const T &search)
{
return v ? v->contains (search) : false;
}
template<typename T, typename A>
inline const T &
vec<T, A, vl_embed>::operator[] (unsigned ix) const
{
((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 870, __FUNCTION__), 0 : 0));
return m_vecdata[ix];
}
template<typename T, typename A>
inline T &
vec<T, A, vl_embed>::operator[] (unsigned ix)
{
((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 878, __FUNCTION__), 0 : 0));
return m_vecdata[ix];
}
template<typename T, typename A>
inline T &
vec<T, A, vl_embed>::last (void)
{
((void)(!(m_vecpfx.m_num > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 889, __FUNCTION__), 0 : 0));
return (*this)[m_vecpfx.m_num - 1];
}
# 900 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::space (unsigned nelems) const
{
return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems;
}
# 915 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const
{
if (ix < m_vecpfx.m_num)
{
*ptr = m_vecdata[ix];
return true;
}
else
{
*ptr = 0;
return false;
}
}
# 941 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const
{
if (ix < m_vecpfx.m_num)
{
*ptr = (const_cast<T *> ((&m_vecdata[ix])));
return true;
}
else
{
*ptr = 0;
return false;
}
}
template<typename T, typename A>
inline vec<T, A, vl_embed> *
vec<T, A, vl_embed>::copy (void) const
{
vec<T, A, vl_embed> *new_vec = nullptr;
unsigned len = length ();
if (len)
{
vec_alloc (new_vec, len );
new_vec->embedded_init (len, len);
vec_copy_construct (new_vec->address (), m_vecdata, len);
}
return new_vec;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src)
{
unsigned len = src.length ();
if (len)
{
((void)(!(space (len)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 986, __FUNCTION__), 0 : 0));
vec_copy_construct (end (), src.address (), len);
m_vecpfx.m_num += len;
}
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src)
{
if (src)
splice (*src);
}
template<typename T, typename A>
inline T *
vec<T, A, vl_embed>::quick_push (const T &obj)
{
((void)(!(space (1)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1009, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[m_vecpfx.m_num++];
*slot = obj;
return slot;
}
template<typename T, typename A>
inline T &
vec<T, A, vl_embed>::pop (void)
{
((void)(!(length () > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1022, __FUNCTION__), 0 : 0));
return m_vecdata[--m_vecpfx.m_num];
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::truncate (unsigned size)
{
((void)(!(length () >= size) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1034, __FUNCTION__), 0 : 0));
m_vecpfx.m_num = size;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj)
{
((void)(!(length () < allocated ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1046, __FUNCTION__), 0 : 0));
((void)(!(ix <= length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1047, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[ix];
memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
*slot = obj;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::ordered_remove (unsigned ix)
{
((void)(!(ix < length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1062, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[ix];
memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
}
# 1105 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::unordered_remove (unsigned ix)
{
((void)(!(ix < length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1109, __FUNCTION__), 0 : 0));
m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num];
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
{
((void)(!(ix + len <= length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1121, __FUNCTION__), 0 : 0));
T *slot = &m_vecdata[ix];
m_vecpfx.m_num -= len;
memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))
{
if (length () > 1)
gcc_qsort (address (), length (), sizeof (T), cmp);
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *),
void *data)
{
if (length () > 1)
gcc_sort_r (address (), length (), sizeof (T), cmp, data);
}
template<typename T, typename A>
inline T *
vec<T, A, vl_embed>::bsearch (const void *key,
int (*compar) (const void *, const void *))
{
const void *base = this->address ();
size_t nmemb = this->length ();
size_t size = sizeof (T);
size_t l, u, idx;
const void *p;
int comparison;
l = 0;
u = nmemb;
while (l < u)
{
idx = (l + u) / 2;
p = (const void *) (((const char *) base) + (idx * size));
comparison = (*compar) (key, p);
if (comparison < 0)
u = idx;
else if (comparison > 0)
l = idx + 1;
else
return (T *)const_cast<void *>(p);
}
return nullptr;
}
template<typename T, typename A>
inline T *
vec<T, A, vl_embed>::bsearch (const void *key,
int (*compar) (const void *, const void *,
void *), void *data)
{
const void *base = this->address ();
size_t nmemb = this->length ();
size_t size = sizeof (T);
size_t l, u, idx;
const void *p;
int comparison;
l = 0;
u = nmemb;
while (l < u)
{
idx = (l + u) / 2;
p = (const void *) (((const char *) base) + (idx * size));
comparison = (*compar) (key, p, data);
if (comparison < 0)
u = idx;
else if (comparison > 0)
l = idx + 1;
else
return (T *)const_cast<void *>(p);
}
return nullptr;
}
template<typename T, typename A>
inline bool
vec<T, A, vl_embed>::contains (const T &search) const
{
unsigned int len = length ();
for (unsigned int i = 0; i < len; i++)
if ((*this)[i] == search)
return true;
return false;
}
template<typename T, typename A>
unsigned
vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &))
const
{
unsigned int len = length ();
unsigned int half, middle;
unsigned int first = 0;
while (len > 0)
{
half = len / 2;
middle = first;
middle += half;
T middle_elem = (*this)[middle];
if (lessthan (middle_elem, obj))
{
first = middle;
++first;
len = len - half - 1;
}
else
len = half;
}
return first;
}
# 1280 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, typename A>
inline size_t
vec<T, A, vl_embed>::embedded_size (unsigned alloc)
{
struct alignas (T) U { char data[sizeof (T)]; };
typedef vec<U, A, vl_embed> vec_embedded;
typedef typename std::conditional<std::is_standard_layout<T>::value,
vec, vec_embedded>::type vec_stdlayout;
static_assert (sizeof (vec_stdlayout) == sizeof (vec), "");
static_assert (alignof (vec_stdlayout) == alignof (vec), "");
return
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
__builtin_offsetof (
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
vec_stdlayout
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
,
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
m_vecdata
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h" 3 4
)
# 1290 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
+ alloc * sizeof (T);
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut)
{
m_vecpfx.m_alloc = alloc;
m_vecpfx.m_using_auto_storage = aut;
m_vecpfx.m_num = num;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::quick_grow (unsigned len)
{
((void)(!(length () <= len && len <= m_vecpfx.m_alloc) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1314, __FUNCTION__), 0 : 0));
m_vecpfx.m_num = len;
}
template<typename T, typename A>
inline void
vec<T, A, vl_embed>::quick_grow_cleared (unsigned len)
{
unsigned oldlen = length ();
size_t growby = len - oldlen;
quick_grow (len);
if (growby != 0)
vec_default_construct (address () + oldlen, growby);
}
template<typename T>
void
gt_ggc_mx (vec<T, va_gc> *v)
{
extern void gt_ggc_mx (T &);
for (unsigned i = 0; i < v->length (); i++)
gt_ggc_mx ((*v)[i]);
}
template<typename T>
void
gt_ggc_mx (vec<T, va_gc_atomic, vl_embed> *v __attribute__ ((__unused__)))
{
}
template<typename T, typename A>
void
gt_pch_nx (vec<T, A, vl_embed> *v)
{
extern void gt_pch_nx (T &);
for (unsigned i = 0; i < v->length (); i++)
gt_pch_nx ((*v)[i]);
}
template<typename T, typename A>
void
gt_pch_nx (vec<T *, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
{
for (unsigned i = 0; i < v->length (); i++)
op (&((*v)[i]), cookie);
}
template<typename T, typename A>
void
gt_pch_nx (vec<T, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
{
extern void gt_pch_nx (T *, gt_pointer_operator, void *);
for (unsigned i = 0; i < v->length (); i++)
gt_pch_nx (&((*v)[i]), op, cookie);
}
# 1410 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
struct vec<T, va_heap, vl_ptr>
{
public:
void create (unsigned nelems );
void release (void);
bool exists (void) const
{ return m_vec != nullptr; }
bool is_empty (void) const
{ return m_vec ? m_vec->is_empty () : true; }
unsigned length (void) const
{ return m_vec ? m_vec->length () : 0; }
T *address (void)
{ return m_vec ? m_vec->m_vecdata : nullptr; }
const T *address (void) const
{ return m_vec ? m_vec->m_vecdata : nullptr; }
T *begin () { return address (); }
const T *begin () const { return address (); }
T *end () { return begin () + length (); }
const T *end () const { return begin () + length (); }
const T &operator[] (unsigned ix) const
{ return (*m_vec)[ix]; }
bool operator!=(const vec &other) const
{ return !(*this == other); }
bool operator==(const vec &other) const
{ return address () == other.address (); }
T &operator[] (unsigned ix)
{ return (*m_vec)[ix]; }
T &last (void)
{ return m_vec->last (); }
bool space (int nelems) const
{ return m_vec ? m_vec->space (nelems) : nelems == 0; }
bool iterate (unsigned ix, T *p) const;
bool iterate (unsigned ix, T **p) const;
vec copy () const;
bool reserve (unsigned, bool = false );
bool reserve_exact (unsigned );
void splice (const vec &);
void safe_splice (const vec & );
T *quick_push (const T &);
T *safe_push (const T &);
T &pop (void);
void truncate (unsigned);
void safe_grow (unsigned );
void safe_grow_cleared (unsigned );
void quick_grow (unsigned);
void quick_grow_cleared (unsigned);
void quick_insert (unsigned, const T &);
void safe_insert (unsigned, const T & );
void ordered_remove (unsigned);
void unordered_remove (unsigned);
void block_remove (unsigned, unsigned);
void qsort (int (*) (const void *, const void *));
void sort (int (*) (const void *, const void *, void *), void *);
T *bsearch (const void *key, int (*compar)(const void *, const void *));
T *bsearch (const void *key,
int (*compar)(const void *, const void *, void *), void *);
unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
bool contains (const T &search) const;
void reverse (void);
bool using_auto_storage () const;
vec<T, va_heap, vl_embed> *m_vec;
};
# 1500 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T, size_t N = 0>
class auto_vec : public vec<T, va_heap>
{
public:
auto_vec ()
{
m_auto.embedded_init (((N) > (2) ? (N) : (2)), 0, 1);
this->m_vec = &m_auto;
}
auto_vec (size_t s)
{
if (s > N)
{
this->create (s);
return;
}
m_auto.embedded_init (((N) > (2) ? (N) : (2)), 0, 1);
this->m_vec = &m_auto;
}
~auto_vec ()
{
this->release ();
}
private:
vec<T, va_heap, vl_embed> m_auto;
T m_data[((N - 1) > (1) ? (N - 1) : (1))];
};
template<typename T>
class auto_vec<T, 0> : public vec<T, va_heap>
{
public:
auto_vec () { this->m_vec = nullptr; }
auto_vec (size_t n) { this->create (n); }
~auto_vec () { this->release (); }
};
template<typename T>
inline void
vec_alloc (vec<T> *&v, unsigned nelems )
{
v = new vec<T>;
v->create (nelems );
}
class auto_string_vec : public auto_vec <char *>
{
public:
~auto_string_vec ();
};
# 1578 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template <typename T>
class auto_delete_vec : public auto_vec <T *>
{
public:
auto_delete_vec () {}
auto_delete_vec (size_t s) : auto_vec <T *> (s) {}
~auto_delete_vec ();
private:
auto_delete_vec<T> (const auto_delete_vec<T>&) = delete; void operator= (const auto_delete_vec<T> &) = delete;
};
template<typename T>
inline void
vec_check_alloc (vec<T, va_heap> *&vec, unsigned nelems )
{
if (!vec)
vec_alloc (vec, nelems );
}
template<typename T>
inline void
vec_free (vec<T> *&v)
{
if (v == nullptr)
return;
v->release ();
delete v;
v = nullptr;
}
# 1624 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T *ptr) const
{
if (m_vec)
return m_vec->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
# 1647 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T **ptr) const
{
if (m_vec)
return m_vec->iterate (ix, ptr);
else
{
*ptr = 0;
return false;
}
}
# 1686 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
inline
auto_string_vec::~auto_string_vec ()
{
int i;
char *str;
for (i = 0; (*this).iterate ((i), &(str)); ++(i))
free (str);
}
template <typename T>
inline
auto_delete_vec<T>::~auto_delete_vec ()
{
int i;
T *item;
for (i = 0; (*this).iterate ((i), &(item)); ++(i))
delete item;
}
template<typename T>
inline vec<T, va_heap, vl_ptr>
vec<T, va_heap, vl_ptr>::copy (void) const
{
vec<T, va_heap, vl_ptr> new_vec = vNULL;
if (length ())
new_vec.m_vec = m_vec->copy ();
return new_vec;
}
# 1731 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h"
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::reserve (unsigned nelems, bool exact )
{
if (space (nelems))
return false;
vec<T, va_heap, vl_embed> *oldvec = m_vec;
unsigned int oldsize = 0;
bool handle_auto_vec = m_vec && using_auto_storage ();
if (handle_auto_vec)
{
m_vec = nullptr;
oldsize = oldvec->length ();
nelems += oldsize;
}
va_heap::reserve (m_vec, nelems, exact );
if (handle_auto_vec)
{
vec_copy_construct (m_vec->address (), oldvec->address (), oldsize);
m_vec->m_vecpfx.m_num = oldsize;
}
return true;
}
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::reserve_exact (unsigned nelems )
{
return reserve (nelems, true );
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::create (unsigned nelems )
{
m_vec = nullptr;
if (nelems > 0)
reserve_exact (nelems );
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::release (void)
{
if (!m_vec)
return;
if (using_auto_storage ())
{
m_vec->m_vecpfx.m_num = 0;
return;
}
va_heap::release (m_vec);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::splice (const vec<T, va_heap, vl_ptr> &src)
{
if (src.length ())
m_vec->splice (*(src.m_vec));
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_splice (const vec<T, va_heap, vl_ptr> &src
)
{
if (src.length ())
{
reserve_exact (src.length ());
splice (src);
}
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::quick_push (const T &obj)
{
return m_vec->quick_push (obj);
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::safe_push (const T &obj )
{
reserve (1, false );
return quick_push (obj);
}
template<typename T>
inline T &
vec<T, va_heap, vl_ptr>::pop (void)
{
return m_vec->pop ();
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::truncate (unsigned size)
{
if (m_vec)
m_vec->truncate (size);
else
((void)(!(size == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1885, __FUNCTION__), 0 : 0));
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_grow (unsigned len )
{
unsigned oldlen = length ();
((void)(!(oldlen <= len) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1898, __FUNCTION__), 0 : 0));
reserve_exact (len - oldlen );
if (m_vec)
m_vec->quick_grow (len);
else
((void)(!(len == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1903, __FUNCTION__), 0 : 0));
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len )
{
unsigned oldlen = length ();
size_t growby = len - oldlen;
safe_grow (len );
if (growby != 0)
vec_default_construct (address () + oldlen, growby);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::quick_grow (unsigned len)
{
((void)(!(m_vec) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1930, __FUNCTION__), 0 : 0));
m_vec->quick_grow (len);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::quick_grow_cleared (unsigned len)
{
((void)(!(m_vec) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vec.h", 1943, __FUNCTION__), 0 : 0));
m_vec->quick_grow_cleared (len);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::quick_insert (unsigned ix, const T &obj)
{
m_vec->quick_insert (ix, obj);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::safe_insert (unsigned ix, const T &obj )
{
reserve (1, false );
quick_insert (ix, obj);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::ordered_remove (unsigned ix)
{
m_vec->ordered_remove (ix);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::unordered_remove (unsigned ix)
{
m_vec->unordered_remove (ix);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::block_remove (unsigned ix, unsigned len)
{
m_vec->block_remove (ix, len);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::qsort (int (*cmp) (const void *, const void *))
{
if (m_vec)
m_vec->qsort (cmp);
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::sort (int (*cmp) (const void *, const void *,
void *), void *data)
{
if (m_vec)
m_vec->sort (cmp, data);
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::bsearch (const void *key,
int (*cmp) (const void *, const void *))
{
if (m_vec)
return m_vec->bsearch (key, cmp);
return nullptr;
}
template<typename T>
inline T *
vec<T, va_heap, vl_ptr>::bsearch (const void *key,
int (*cmp) (const void *, const void *,
void *), void *data)
{
if (m_vec)
return m_vec->bsearch (key, cmp, data);
return nullptr;
}
template<typename T>
inline unsigned
vec<T, va_heap, vl_ptr>::lower_bound (T obj,
bool (*lessthan)(const T &, const T &))
const
{
return m_vec ? m_vec->lower_bound (obj, lessthan) : 0;
}
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::contains (const T &search) const
{
return m_vec ? m_vec->contains (search) : false;
}
template<typename T>
inline void
vec<T, va_heap, vl_ptr>::reverse (void)
{
unsigned l = length ();
T *ptr = address ();
for (unsigned i = 0; i < l / 2; i++)
std::swap (ptr[i], ptr[l - i - 1]);
}
template<typename T>
inline bool
vec<T, va_heap, vl_ptr>::using_auto_storage () const
{
return m_vec->m_vecpfx.m_using_auto_storage;
}
template<typename T>
inline void
release_vec_vec (vec<vec<T> > &vec)
{
for (unsigned i = 0; i < vec.length (); i++)
vec[i].release ();
vec.release ();
}
# 249 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/hashtab.h" 1
# 250 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/inchash.h" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/inchash.h"
hashval_t iterative_hash_host_wide_int (long, hashval_t);
hashval_t iterative_hash_hashval_t (hashval_t, hashval_t);
namespace inchash
{
class hash
{
public:
hash (hashval_t seed = 0)
{
val = seed;
bits = 0;
}
hashval_t end ()
{
return val;
}
void add_int (unsigned v)
{
val = iterative_hash_hashval_t (v, val);
}
template<unsigned int N, typename T>
void add_poly_int (const poly_int_pod<N, T> &v)
{
for (unsigned int i = 0; i < N; ++i)
add_int (v.coeffs[i]);
}
void add_hwi (long v)
{
val = iterative_hash_host_wide_int (v, val);
}
template<unsigned int N, typename T>
void add_poly_hwi (const poly_int_pod<N, T> &v)
{
for (unsigned int i = 0; i < N; ++i)
add_hwi (v.coeffs[i]);
}
template<typename T>
void add_wide_int (const generic_wide_int<T> &x)
{
add_int (x.get_len ());
for (unsigned i = 0; i < x.get_len (); i++)
add_hwi (x.sext_elt (i));
}
void add_ptr (const void *ptr)
{
add (&ptr, sizeof (ptr));
}
void add (const void *data, size_t len)
{
val = iterative_hash (data, len, val);
}
void merge_hash (hashval_t other)
{
val = iterative_hash_hashval_t (other, val);
}
void merge (hash &other)
{
merge_hash (other.val);
}
template<class T> void add_object(T &obj)
{
add (&obj, sizeof(T));
}
void add_flag (bool flag)
{
bits = (bits << 1) | flag;
}
void commit_flag ()
{
add_int (bits);
bits = 0;
}
void add_commutative (hash &a, hash &b)
{
if (a.end() > b.end())
{
merge (b);
merge (a);
}
else
{
merge (a);
merge (b);
}
}
private:
hashval_t val;
unsigned bits;
};
}
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/inchash.h"
inline
hashval_t
iterative_hash_hashval_t (hashval_t val, hashval_t val2)
{
hashval_t a = 0x9e3779b9;
{ a -= val; a -= val2; a ^= (val2>>13); val -= val2; val -= a; val ^= (a<< 8); val2 -= a; val2 -= val; val2 ^= ((val&0xffffffff)>>13); a -= val; a -= val2; a ^= ((val2&0xffffffff)>>12); val -= val2; val -= a; val = (val ^ (a<<16)) & 0xffffffff; val2 -= a; val2 -= val; val2 = (val2 ^ (val>> 5)) & 0xffffffff; a -= val; a -= val2; a = (a ^ (val2>> 3)) & 0xffffffff; val -= val2; val -= a; val = (val ^ (a<<10)) & 0xffffffff; val2 -= a; val2 -= val; val2 = (val2 ^ (val>>15)) & 0xffffffff; };
return val2;
}
inline
hashval_t
iterative_hash_host_wide_int (long val, hashval_t val2)
{
if (sizeof (long) == sizeof (hashval_t))
return iterative_hash_hashval_t (val, val2);
else
{
hashval_t a = (hashval_t) val;
int zero = 0;
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
{ a -= b; a -= val2; a ^= (val2>>13); b -= val2; b -= a; b ^= (a<< 8); val2 -= a; val2 -= b; val2 ^= ((b&0xffffffff)>>13); a -= b; a -= val2; a ^= ((val2&0xffffffff)>>12); b -= val2; b -= a; b = (b ^ (a<<16)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>> 5)) & 0xffffffff; a -= b; a -= val2; a = (a ^ (val2>> 3)) & 0xffffffff; b -= val2; b -= a; b = (b ^ (a<<10)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>>15)) & 0xffffffff; };
if (sizeof (long) > 2 * sizeof (hashval_t))
{
hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
{ a -= b; a -= val2; a ^= (val2>>13); b -= val2; b -= a; b ^= (a<< 8); val2 -= a; val2 -= b; val2 ^= ((b&0xffffffff)>>13); a -= b; a -= val2; a ^= ((val2&0xffffffff)>>12); b -= val2; b -= a; b = (b ^ (a<<16)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>> 5)) & 0xffffffff; a -= b; a -= val2; a = (a ^ (val2>> 3)) & 0xffffffff; b -= val2; b -= a; b = (b ^ (a<<10)) & 0xffffffff; val2 -= a; val2 -= b; val2 = (val2 ^ (b>>15)) & 0xffffffff; };
}
return val2;
}
}
# 251 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats-traits.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats-traits.h"
enum mem_alloc_origin
{
HASH_TABLE_ORIGIN,
HASH_MAP_ORIGIN,
HASH_SET_ORIGIN,
VEC_ORIGIN,
BITMAP_ORIGIN,
GGC_ORIGIN,
ALLOC_POOL_ORIGIN,
MEM_ALLOC_ORIGIN_LENGTH
};
static const char * mem_alloc_origin_names[] = { "Hash tables", "Hash maps",
"Hash sets", "Heap vectors", "Bitmaps", "GGC memory", "Allocation pool" };
# 252 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-traits.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-traits.h"
template <typename Type>
struct typed_free_remove
{
static inline void remove (Type *p);
};
template <typename Type>
inline void
typed_free_remove <Type>::remove (Type *p)
{
free (p);
}
template <typename Type>
struct typed_delete_remove
{
static inline void remove (Type *p);
};
template <typename Type>
inline void
typed_delete_remove <Type>::remove (Type *p)
{
delete p;
}
template <typename Type>
struct typed_noop_remove
{
static inline void remove (Type &);
};
template <typename Type>
inline void
typed_noop_remove <Type>::remove (Type &)
{
}
template <typename Type, Type Empty, Type Deleted = Empty>
struct int_hash : typed_noop_remove <Type>
{
typedef Type value_type;
typedef Type compare_type;
static inline hashval_t hash (value_type);
static inline bool equal (value_type existing, value_type candidate);
static inline void mark_deleted (Type &);
static const bool empty_zero_p = Empty == 0;
static inline void mark_empty (Type &);
static inline bool is_deleted (Type);
static inline bool is_empty (Type);
};
template <typename Type, Type Empty, Type Deleted>
inline hashval_t
int_hash <Type, Empty, Deleted>::hash (value_type x)
{
return x;
}
template <typename Type, Type Empty, Type Deleted>
inline bool
int_hash <Type, Empty, Deleted>::equal (value_type x, value_type y)
{
return x == y;
}
template <typename Type, Type Empty, Type Deleted>
inline void
int_hash <Type, Empty, Deleted>::mark_deleted (Type &x)
{
((void)(!(Empty != Deleted) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-traits.h", 115, __FUNCTION__), 0 : 0));
x = Deleted;
}
template <typename Type, Type Empty, Type Deleted>
inline void
int_hash <Type, Empty, Deleted>::mark_empty (Type &x)
{
x = Empty;
}
template <typename Type, Type Empty, Type Deleted>
inline bool
int_hash <Type, Empty, Deleted>::is_deleted (Type x)
{
return Empty != Deleted && x == Deleted;
}
template <typename Type, Type Empty, Type Deleted>
inline bool
int_hash <Type, Empty, Deleted>::is_empty (Type x)
{
return x == Empty;
}
template <typename Type>
struct pointer_hash
{
typedef Type *value_type;
typedef Type *compare_type;
static inline hashval_t hash (const value_type &);
static inline bool equal (const value_type &existing,
const compare_type &candidate);
static inline void mark_deleted (Type *&);
static const bool empty_zero_p = true;
static inline void mark_empty (Type *&);
static inline bool is_deleted (Type *);
static inline bool is_empty (Type *);
};
template <typename Type>
inline hashval_t
pointer_hash <Type>::hash (const value_type &candidate)
{
return (hashval_t) ((intptr_t)candidate >> 3);
}
template <typename Type>
inline bool
pointer_hash <Type>::equal (const value_type &existing,
const compare_type &candidate)
{
return existing == candidate;
}
template <typename Type>
inline void
pointer_hash <Type>::mark_deleted (Type *&e)
{
e = reinterpret_cast<Type *> (1);
}
template <typename Type>
inline void
pointer_hash <Type>::mark_empty (Type *&e)
{
e = nullptr;
}
template <typename Type>
inline bool
pointer_hash <Type>::is_deleted (Type *e)
{
return e == reinterpret_cast<Type *> (1);
}
template <typename Type>
inline bool
pointer_hash <Type>::is_empty (Type *e)
{
return e == nullptr;
}
struct string_hash : pointer_hash <const char>
{
static inline hashval_t hash (const char *);
static inline bool equal (const char *, const char *);
};
inline hashval_t
string_hash::hash (const char *id)
{
return htab_hash_string (id);
}
inline bool
string_hash::equal (const char *id1, const char *id2)
{
return strcmp (id1, id2) == 0;
}
template<typename T>
struct ggc_remove
{
static void remove (T &) {}
static void
ggc_mx (T &p)
{
extern void gt_ggc_mx (T &);
gt_ggc_mx (p);
}
static void
ggc_maybe_mx (T &p)
{
ggc_mx (p);
}
static void
pch_nx (T &p)
{
extern void gt_pch_nx (T &);
gt_pch_nx (p);
}
static void
pch_nx (T &p, gt_pointer_operator op, void *cookie)
{
op (&p, cookie);
}
};
template<typename T>
struct ggc_cache_remove : ggc_remove<T>
{
static void ggc_maybe_mx (T &) {}
static int
keep_cache_entry (T &e)
{
return ggc_marked_p (e) ? -1 : 0;
}
};
template <typename T>
struct nofree_ptr_hash : pointer_hash <T>, typed_noop_remove <T *> {};
template <typename T>
struct free_ptr_hash : pointer_hash <T>, typed_free_remove <T> {};
template <typename T>
struct delete_ptr_hash : pointer_hash <T>, typed_delete_remove <T> {};
template <typename T>
struct ggc_ptr_hash : pointer_hash <T>, ggc_remove <T *> {};
template <typename T>
struct ggc_cache_ptr_hash : pointer_hash <T>, ggc_cache_remove <T *> {};
struct nofree_string_hash : string_hash, typed_noop_remove <const char *> {};
template <typename T1, typename T2>
struct pair_hash
{
typedef std::pair <typename T1::value_type,
typename T2::value_type> value_type;
typedef std::pair <typename T1::compare_type,
typename T2::compare_type> compare_type;
static inline hashval_t hash (const value_type &);
static inline bool equal (const value_type &, const compare_type &);
static inline void remove (value_type &);
static inline void mark_deleted (value_type &);
static const bool empty_zero_p = T1::empty_zero_p;
static inline void mark_empty (value_type &);
static inline bool is_deleted (const value_type &);
static inline bool is_empty (const value_type &);
};
template <typename T1, typename T2>
inline hashval_t
pair_hash <T1, T2>::hash (const value_type &x)
{
return iterative_hash_hashval_t (T1::hash (x.first), T2::hash (x.second));
}
template <typename T1, typename T2>
inline bool
pair_hash <T1, T2>::equal (const value_type &x, const compare_type &y)
{
return T1::equal (x.first, y.first) && T2::equal (x.second, y.second);
}
template <typename T1, typename T2>
inline void
pair_hash <T1, T2>::remove (value_type &x)
{
T1::remove (x.first);
T2::remove (x.second);
}
template <typename T1, typename T2>
inline void
pair_hash <T1, T2>::mark_deleted (value_type &x)
{
T1::mark_deleted (x.first);
}
template <typename T1, typename T2>
inline void
pair_hash <T1, T2>::mark_empty (value_type &x)
{
T1::mark_empty (x.first);
}
template <typename T1, typename T2>
inline bool
pair_hash <T1, T2>::is_deleted (const value_type &x)
{
return T1::is_deleted (x.first);
}
template <typename T1, typename T2>
inline bool
pair_hash <T1, T2>::is_empty (const value_type &x)
{
return T1::is_empty (x.first);
}
template <typename T> struct default_hash_traits : T {};
template <typename T>
struct default_hash_traits <T *> : ggc_ptr_hash <T> {};
# 253 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map-traits.h" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map-traits.h"
template <typename H, typename Value>
struct simple_hashmap_traits
{
typedef typename H::value_type key_type;
static const bool maybe_mx = true;
static inline hashval_t hash (const key_type &);
static inline bool equal_keys (const key_type &, const key_type &);
template <typename T> static inline void remove (T &);
static const bool empty_zero_p = H::empty_zero_p;
template <typename T> static inline bool is_empty (const T &);
template <typename T> static inline bool is_deleted (const T &);
template <typename T> static inline void mark_empty (T &);
template <typename T> static inline void mark_deleted (T &);
};
template <typename H, typename Value>
inline hashval_t
simple_hashmap_traits <H, Value>::hash (const key_type &h)
{
return H::hash (h);
}
template <typename H, typename Value>
inline bool
simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
const key_type &k2)
{
return H::equal (k1, k2);
}
template <typename H, typename Value>
template <typename T>
inline void
simple_hashmap_traits <H, Value>::remove (T &entry)
{
H::remove (entry.m_key);
entry.m_value.~Value ();
}
template <typename H, typename Value>
template <typename T>
inline bool
simple_hashmap_traits <H, Value>::is_empty (const T &entry)
{
return H::is_empty (entry.m_key);
}
template <typename H, typename Value>
template <typename T>
inline bool
simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
{
return H::is_deleted (entry.m_key);
}
template <typename H, typename Value>
template <typename T>
inline void
simple_hashmap_traits <H, Value>::mark_empty (T &entry)
{
H::mark_empty (entry.m_key);
}
template <typename H, typename Value>
template <typename T>
inline void
simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
{
H::mark_deleted (entry.m_key);
}
template <typename H, typename Value>
struct simple_cache_map_traits: public simple_hashmap_traits<H,Value>
{
static const bool maybe_mx = false;
};
template <typename Value>
struct unbounded_hashmap_traits
{
template <typename T> static inline void remove (T &);
static const bool empty_zero_p = default_hash_traits <Value>::empty_zero_p;
template <typename T> static inline bool is_empty (const T &);
template <typename T> static inline bool is_deleted (const T &);
template <typename T> static inline void mark_empty (T &);
template <typename T> static inline void mark_deleted (T &);
};
template <typename Value>
template <typename T>
inline void
unbounded_hashmap_traits <Value>::remove (T &entry)
{
default_hash_traits <Value>::remove (entry.m_value);
}
template <typename Value>
template <typename T>
inline bool
unbounded_hashmap_traits <Value>::is_empty (const T &entry)
{
return default_hash_traits <Value>::is_empty (entry.m_value);
}
template <typename Value>
template <typename T>
inline bool
unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
{
return default_hash_traits <Value>::is_deleted (entry.m_value);
}
template <typename Value>
template <typename T>
inline void
unbounded_hashmap_traits <Value>::mark_empty (T &entry)
{
default_hash_traits <Value>::mark_empty (entry.m_value);
}
template <typename Value>
template <typename T>
inline void
unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
{
default_hash_traits <Value>::mark_deleted (entry.m_value);
}
template <typename Key, typename Value>
struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
{
typedef Key key_type;
static inline hashval_t hash (Key);
static inline bool equal_keys (Key, Key);
};
template <typename Key, typename Value>
inline hashval_t
unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
{
return k;
}
template <typename Key, typename Value>
inline bool
unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
{
return k1 == k2;
}
# 254 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
template<typename, typename, typename> class hash_map;
template<typename, bool, typename> class hash_set;
template <typename Type>
struct xcallocator
{
static Type *data_alloc (size_t count);
static void data_free (Type *memory);
};
template <typename Type>
inline Type *
xcallocator <Type>::data_alloc (size_t count)
{
return static_cast <Type *> (xcalloc (count, sizeof (Type)));
}
template <typename Type>
inline void
xcallocator <Type>::data_free (Type *memory)
{
return ::free (memory);
}
struct prime_ent
{
hashval_t prime;
hashval_t inv;
hashval_t inv_m2;
hashval_t shift;
};
extern struct prime_ent const prime_tab[];
extern unsigned int hash_table_sanitize_eq_limit;
extern unsigned int hash_table_higher_prime_index (unsigned long n)
__attribute__ ((__pure__));
extern __attribute__ ((__noreturn__)) __attribute__ ((__cold__)) void hashtab_chk_error ();
# 322 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
inline hashval_t
mul_mod (hashval_t x, hashval_t y, hashval_t inv, int shift)
{
hashval_t t1, t2, t3, t4, q, r;
t1 = ((uint64_t)x * inv) >> 32;
t2 = x - t1;
t3 = t2 >> 1;
t4 = t1 + t3;
q = t4 >> shift;
r = x - (q * y);
return r;
}
inline hashval_t
hash_table_mod1 (hashval_t hash, unsigned int index)
{
const struct prime_ent *p = &prime_tab[index];
((void)(!(sizeof (hashval_t) * 8 <= 32) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 343, __FUNCTION__), 0 : 0));
return mul_mod (hash, p->prime, p->inv, p->shift);
}
inline hashval_t
hash_table_mod2 (hashval_t hash, unsigned int index)
{
const struct prime_ent *p = &prime_tab[index];
((void)(!(sizeof (hashval_t) * 8 <= 32) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 353, __FUNCTION__), 0 : 0));
return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift);
}
class mem_usage;
# 372 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template <typename Descriptor, bool Lazy = false,
template<typename Type> class Allocator = xcallocator>
class hash_table
{
typedef typename Descriptor::value_type value_type;
typedef typename Descriptor::compare_type compare_type;
public:
explicit hash_table (size_t, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0,
mem_alloc_origin origin = HASH_TABLE_ORIGIN
);
explicit hash_table (const hash_table &, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0,
mem_alloc_origin origin = HASH_TABLE_ORIGIN
);
~hash_table ();
static hash_table *
create_ggc (size_t n, bool sanitize_eq_and_hash = true )
{
hash_table *table = ggc_alloc<hash_table> ();
new (table) hash_table (n, true, sanitize_eq_and_hash, 0,
HASH_TABLE_ORIGIN );
return table;
}
size_t size () const { return m_size; }
size_t elements () const { return m_n_elements - m_n_deleted; }
size_t elements_with_deleted () const { return m_n_elements; }
void empty () { if (elements ()) empty_slow (); }
bool is_empty () const { return elements () == 0; }
void clear_slot (value_type *);
value_type &find_with_hash (const compare_type &, hashval_t);
value_type &find (const value_type &value)
{
return find_with_hash (value, Descriptor::hash (value));
}
value_type *find_slot (const value_type &value, insert_option insert)
{
return find_slot_with_hash (value, Descriptor::hash (value), insert);
}
# 445 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
value_type *find_slot_with_hash (const compare_type &comparable,
hashval_t hash, enum insert_option insert);
void remove_elt_with_hash (const compare_type &, hashval_t);
void remove_elt (const value_type &value)
{
remove_elt_with_hash (value, Descriptor::hash (value));
}
template <typename Argument,
int (*Callback) (value_type *slot, Argument argument)>
void traverse_noresize (Argument argument);
template <typename Argument,
int (*Callback) (value_type *slot, Argument argument)>
void traverse (Argument argument);
class iterator
{
public:
iterator () : m_slot (nullptr), m_limit (nullptr) {}
iterator (value_type *slot, value_type *limit) :
m_slot (slot), m_limit (limit) {}
inline value_type &operator * () { return *m_slot; }
void slide ();
inline iterator &operator ++ ();
bool operator != (const iterator &other) const
{
return m_slot != other.m_slot || m_limit != other.m_limit;
}
private:
value_type *m_slot;
value_type *m_limit;
};
iterator begin () const
{
if (Lazy && m_entries == nullptr)
return iterator ();
iterator iter (m_entries, m_entries + m_size);
iter.slide ();
return iter;
}
iterator end () const { return iterator (); }
double collisions () const
{
return m_searches ? static_cast <double> (m_collisions) / m_searches : 0;
}
private:
void operator= (hash_table&);
template<typename T> friend void gt_ggc_mx (hash_table<T> *);
template<typename T> friend void gt_pch_nx (hash_table<T> *);
template<typename T> friend void
hashtab_entry_note_pointers (void *, void *, gt_pointer_operator, void *);
template<typename T, typename U, typename V> friend void
gt_pch_nx (hash_map<T, U, V> *, gt_pointer_operator, void *);
template<typename T, typename U>
friend void gt_pch_nx (hash_set<T, false, U> *, gt_pointer_operator, void *);
template<typename T> friend void gt_pch_nx (hash_table<T> *,
gt_pointer_operator, void *);
template<typename T> friend void gt_cleare_cache (hash_table<T> *);
void empty_slow ();
value_type *alloc_entries (size_t n ) const;
value_type *find_empty_slot_for_expand (hashval_t);
void verify (const compare_type &comparable, hashval_t hash);
bool too_empty_p (unsigned int);
void expand ();
static bool is_deleted (value_type &v)
{
return Descriptor::is_deleted (v);
}
static bool is_empty (value_type &v)
{
return Descriptor::is_empty (v);
}
static void mark_deleted (value_type &v)
{
Descriptor::mark_deleted (v);
}
static void mark_empty (value_type &v)
{
Descriptor::mark_empty (v);
}
typename Descriptor::value_type *m_entries;
size_t m_size;
size_t m_n_elements;
size_t m_n_deleted;
unsigned int m_searches;
unsigned int m_collisions;
unsigned int m_size_prime_index;
bool m_ggc;
bool m_sanitize_eq_and_hash;
static const bool m_gather_mem_stats = false;
};
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
template<typename Key, typename Value,
typename Traits = simple_hashmap_traits<default_hash_traits<Key>,
Value> >
class hash_map;
class mem_location
{
public:
inline
mem_location () {}
inline
mem_location (mem_alloc_origin origin, bool ggc,
const char *filename = nullptr, int line = 0,
const char *function = nullptr):
m_filename (filename), m_function (function), m_line (line), m_origin
(origin), m_ggc (ggc) {}
inline
mem_location (mem_location &other): m_filename (other.m_filename),
m_function (other.m_function), m_line (other.m_line),
m_origin (other.m_origin), m_ggc (other.m_ggc) {}
hashval_t
hash ()
{
inchash::hash hash;
hash.add_ptr (m_filename);
hash.add_ptr (m_function);
hash.add_int (m_line);
return hash.end ();
}
int
equal (const mem_location &other)
{
return m_filename == other.m_filename && m_function == other.m_function
&& m_line == other.m_line;
}
inline const char *
get_trimmed_filename ()
{
const char *s1 = m_filename;
const char *s2;
while ((s2 = strstr (s1, "gcc/")))
s1 = s2 + 4;
return s1;
}
inline char *
to_string ()
{
unsigned l = strlen (get_trimmed_filename ()) + strlen (m_function)
+ 30;
char *s = ((char *) xmalloc (sizeof (char) * (l)));
sprintf (s, "%s:%i (%s)", get_trimmed_filename (),
m_line, m_function);
s[((48) < (l - 1) ? (48) : (l - 1))] = '\0';
return s;
}
static const char *
get_origin_name (mem_alloc_origin origin)
{
return mem_alloc_origin_names[(unsigned) origin];
}
const char *m_filename;
const char *m_function;
int m_line;
mem_alloc_origin m_origin;
bool m_ggc;
};
class mem_usage
{
public:
mem_usage (): m_allocated (0), m_times (0), m_peak (0), m_instances (1) {}
mem_usage (size_t allocated, size_t times, size_t peak, size_t instances = 0):
m_allocated (allocated), m_times (times), m_peak (peak),
m_instances (instances) {}
inline void
register_overhead (size_t size)
{
m_allocated += size;
m_times++;
if (m_peak < m_allocated)
m_peak = m_allocated;
}
inline void
release_overhead (size_t size)
{
((void)(!(size <= m_allocated) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h", 153, __FUNCTION__), 0 : 0));
m_allocated -= size;
}
mem_usage
operator+ (const mem_usage &second)
{
return mem_usage (m_allocated + second.m_allocated,
m_times + second.m_times,
m_peak + second.m_peak,
m_instances + second.m_instances);
}
inline bool
operator== (const mem_usage &second) const
{
return (m_allocated == second.m_allocated
&& m_peak == second.m_peak
&& m_times == second.m_times);
}
inline bool
operator< (const mem_usage &second) const
{
if (*this == second)
return false;
return (m_allocated == second.m_allocated ?
(m_peak == second.m_peak ? m_times < second.m_times
: m_peak < second.m_peak) : m_allocated < second.m_allocated);
}
static int
compare (const void *first, const void *second)
{
typedef std::pair<mem_location *, mem_usage *> mem_pair_t;
const mem_pair_t f = *(const mem_pair_t *)first;
const mem_pair_t s = *(const mem_pair_t *)second;
if (*f.second == *s.second)
return 0;
return *f.second < *s.second ? 1 : -1;
}
inline void
dump (mem_location *loc, const mem_usage &total) const
{
char *location_string = loc->to_string ();
fprintf (
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "%-48s " "%" "9"
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" ":%5.1f%%"
"%" "9"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" "%" "9"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" ":%5.1f%%%10s\n",
location_string, (uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_allocated, total.m_allocated),
(uint64_t)(((m_peak) < 10 * 1024 ? (m_peak) : ((m_peak) < 10 * (1024 * 1024) ? (m_peak) / 1024 : (m_peak) / (1024 * 1024)))), ((m_peak) < 10 * 1024 ? ' ' : ((m_peak) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_times) < 10 * 1024 ? (m_times) : ((m_times) < 10 * (1024 * 1024) ? (m_times) / 1024 : (m_times) / (1024 * 1024)))), ((m_times) < 10 * 1024 ? ' ' : ((m_times) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_times, total.m_times), loc->m_ggc ? "ggc" : "heap");
free (location_string);
}
inline void
dump_footer () const
{
fprintf (
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "%s" "%" "53"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" "%" "26"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
"l" "u"
# 224 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
"%c" "\n", "Total",
(uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_times) < 10 * 1024 ? (m_times) : ((m_times) < 10 * (1024 * 1024) ? (m_times) / 1024 : (m_times) / (1024 * 1024)))), ((m_times) < 10 * 1024 ? ' ' : ((m_times) < 10 * (1024 * 1024) ? 'k' : 'M')));
}
static inline float
get_percent (size_t nominator, size_t denominator)
{
return denominator == 0 ? 0.0f : nominator * 100.0 / denominator;
}
static inline void
print_dash_line (size_t count = 140)
{
while (count--)
fputc ('-',
# 240 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 240 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
);
fputc ('\n',
# 241 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 241 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
);
}
static inline void
dump_header (const char *name)
{
fprintf (
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "%-48s %11s%16s%10s%17s\n", name, "Leak", "Peak",
"Times", "Type");
}
size_t m_allocated;
size_t m_times;
size_t m_peak;
size_t m_instances;
};
template <class T>
class mem_usage_pair
{
public:
mem_usage_pair (T *usage_, size_t allocated_): usage (usage_),
allocated (allocated_) {}
T *usage;
size_t allocated;
};
template <class T>
class mem_alloc_description
{
public:
struct mem_location_hash : nofree_ptr_hash <mem_location>
{
static hashval_t
hash (value_type l)
{
inchash::hash hstate;
hstate.add_ptr ((const void *)l->m_filename);
hstate.add_ptr (l->m_function);
hstate.add_int (l->m_line);
return hstate.end ();
}
static bool
equal (value_type l1, value_type l2)
{
return (l1->m_filename == l2->m_filename
&& l1->m_function == l2->m_function
&& l1->m_line == l2->m_line);
}
};
typedef hash_map <mem_location_hash, T *> mem_map_t;
typedef hash_map <const void *, mem_usage_pair<T> > reverse_mem_map_t;
typedef hash_map <const void *, std::pair<T *, size_t> > reverse_object_map_t;
typedef std::pair <mem_location *, T *> mem_list_t;
mem_alloc_description ();
~mem_alloc_description ();
bool contains_descriptor_for_instance (const void *ptr);
T *get_descriptor_for_instance (const void *ptr);
T *register_descriptor (const void *ptr, mem_location *location);
T *register_descriptor (const void *ptr, mem_alloc_origin origin,
bool ggc, const char *name, int line,
const char *function);
T *register_instance_overhead (size_t size, const void *ptr);
void register_object_overhead (T *usage, size_t size, const void *ptr);
T *release_instance_overhead (void *ptr, size_t size,
bool remove_from_map = false);
void release_object_overhead (void *ptr);
void unregister_descriptor (void *ptr);
T get_sum (mem_alloc_origin origin);
mem_list_t *get_list (mem_alloc_origin origin, unsigned *length);
void dump (mem_alloc_origin origin);
reverse_object_map_t *m_reverse_object_map;
private:
T *register_overhead (size_t size, mem_alloc_origin origin, const char *name,
int line, const char *function, const void *ptr);
mem_location m_location;
mem_map_t *m_map;
reverse_mem_map_t *m_reverse_map;
};
template <class T>
inline bool
mem_alloc_description<T>::contains_descriptor_for_instance (const void *ptr)
{
return m_reverse_map->get (ptr);
}
template <class T>
inline T*
mem_alloc_description<T>::get_descriptor_for_instance (const void *ptr)
{
return m_reverse_map->get (ptr) ? (*m_reverse_map->get (ptr)).usage : nullptr;
}
template <class T>
inline T*
mem_alloc_description<T>::register_descriptor (const void *ptr,
mem_location *location)
{
T *usage = nullptr;
T **slot = m_map->get (location);
if (slot)
{
delete location;
usage = *slot;
usage->m_instances++;
}
else
{
usage = new T ();
m_map->put (location, usage);
}
if (!m_reverse_map->get (ptr))
m_reverse_map->put (ptr, mem_usage_pair<T> (usage, 0));
return usage;
}
template <class T>
inline T*
mem_alloc_description<T>::register_descriptor (const void *ptr,
mem_alloc_origin origin,
bool ggc,
const char *filename,
int line,
const char *function)
{
mem_location *l = new mem_location (origin, ggc, filename, line, function);
return register_descriptor (ptr, l);
}
template <class T>
inline T*
mem_alloc_description<T>::register_instance_overhead (size_t size,
const void *ptr)
{
mem_usage_pair <T> *slot = m_reverse_map->get (ptr);
if (!slot)
{
return nullptr;
}
T *usage = (*slot).usage;
usage->register_overhead (size);
return usage;
}
template <class T>
void
mem_alloc_description<T>::register_object_overhead (T *usage, size_t size,
const void *ptr)
{
m_reverse_object_map->put (ptr, std::pair<T *, size_t> (usage, size));
}
template <class T>
inline T*
mem_alloc_description<T>::register_overhead (size_t size,
mem_alloc_origin origin,
const char *filename,
int line,
const char *function,
const void *ptr)
{
T *usage = register_descriptor (ptr, origin, filename, line, function);
usage->register_overhead (size);
return usage;
}
template <class T>
inline T *
mem_alloc_description<T>::release_instance_overhead (void *ptr, size_t size,
bool remove_from_map)
{
mem_usage_pair<T> *slot = m_reverse_map->get (ptr);
if (!slot)
{
return nullptr;
}
T *usage = (*slot).usage;
usage->release_overhead (size);
if (remove_from_map)
m_reverse_map->remove (ptr);
return usage;
}
template <class T>
inline void
mem_alloc_description<T>::release_object_overhead (void *ptr)
{
std::pair <T *, size_t> *entry = m_reverse_object_map->get (ptr);
entry->first->release_overhead (entry->second);
m_reverse_object_map->remove (ptr);
}
template <class T>
inline void
mem_alloc_description<T>::unregister_descriptor (void *ptr)
{
m_reverse_map->remove (ptr);
}
template <class T>
inline
mem_alloc_description<T>::mem_alloc_description ()
{
m_map = new mem_map_t (13, false, false, false);
m_reverse_map = new reverse_mem_map_t (13, false, false, false);
m_reverse_object_map = new reverse_object_map_t (13, false, false, false);
}
template <class T>
inline
mem_alloc_description<T>::~mem_alloc_description ()
{
for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
++it)
{
delete (*it).first;
delete (*it).second;
}
delete m_map;
delete m_reverse_map;
delete m_reverse_object_map;
}
template <class T>
inline
typename mem_alloc_description<T>::mem_list_t *
mem_alloc_description<T>::get_list (mem_alloc_origin origin, unsigned *length)
{
size_t element_size = sizeof (mem_list_t);
mem_list_t *list = ((mem_list_t *) xcalloc ((m_map->elements ()), sizeof (mem_list_t)));
unsigned i = 0;
for (typename mem_map_t::iterator it = m_map->begin (); it != m_map->end ();
++it)
if ((*it).first->m_origin == origin)
list[i++] = std::pair<mem_location*, T*> (*it);
gcc_qsort (list, i, element_size, T::compare);
*length = i;
return list;
}
template <class T>
inline T
mem_alloc_description<T>::get_sum (mem_alloc_origin origin)
{
unsigned length;
mem_list_t *list = get_list (origin, &length);
T sum;
for (unsigned i = 0; i < length; i++)
sum = sum + *list[i].second;
free ((void*) (list));
return sum;
}
template <class T>
inline void
mem_alloc_description<T>::dump (mem_alloc_origin origin)
{
unsigned length;
fprintf (
# 636 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 636 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "\n");
mem_list_t *list = get_list (origin, &length);
T total = get_sum (origin);
T::print_dash_line ();
T::dump_header (mem_location::get_origin_name (origin));
T::print_dash_line ();
for (int i = length - 1; i >= 0; i--)
list[i].second->dump (list[i].first, total);
T::print_dash_line ();
T::dump_header (mem_location::get_origin_name (origin));
T::print_dash_line ();
total.dump_footer ();
T::print_dash_line ();
free ((void*) (list));
fprintf (
# 655 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h" 3 4
stderr
# 655 "/home/giulianob/gcc_git_gnu/gcc/gcc/mem-stats.h"
, "\n");
}
# 595 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map.h" 1
# 35 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-map.h"
const size_t default_hash_map_size = 13;
template<typename KeyId, typename Value,
typename Traits
>
class hash_map
{
typedef typename Traits::key_type Key;
struct hash_entry
{
Key m_key;
Value m_value;
typedef hash_entry value_type;
typedef Key compare_type;
static hashval_t hash (const hash_entry &e)
{
return Traits::hash (e.m_key);
}
static bool equal (const hash_entry &a, const Key &b)
{
return Traits::equal_keys (a.m_key, b);
}
static void remove (hash_entry &e) { Traits::remove (e); }
static void mark_deleted (hash_entry &e) { Traits::mark_deleted (e); }
static bool is_deleted (const hash_entry &e)
{
return Traits::is_deleted (e);
}
static const bool empty_zero_p = Traits::empty_zero_p;
static void mark_empty (hash_entry &e) { Traits::mark_empty (e); }
static bool is_empty (const hash_entry &e) { return Traits::is_empty (e); }
static void ggc_mx (hash_entry &e)
{
gt_ggc_mx (e.m_key);
gt_ggc_mx (e.m_value);
}
static void ggc_maybe_mx (hash_entry &e)
{
if (Traits::maybe_mx)
ggc_mx (e);
}
static void pch_nx (hash_entry &e)
{
gt_pch_nx (e.m_key);
gt_pch_nx (e.m_value);
}
static void pch_nx (hash_entry &e, gt_pointer_operator op, void *c)
{
pch_nx_helper (e.m_key, op, c);
pch_nx_helper (e.m_value, op, c);
}
static int keep_cache_entry (hash_entry &e)
{
return ggc_marked_p (e.m_key);
}
private:
template<typename T>
static void
pch_nx_helper (T &x, gt_pointer_operator op, void *cookie)
{
gt_pch_nx (&x, op, cookie);
}
static void
pch_nx_helper (int, gt_pointer_operator, void *)
{
}
static void
pch_nx_helper (unsigned int, gt_pointer_operator, void *)
{
}
static void
pch_nx_helper (bool, gt_pointer_operator, void *)
{
}
template<typename T>
static void
pch_nx_helper (T *&x, gt_pointer_operator op, void *cookie)
{
op (&x, cookie);
}
};
public:
explicit hash_map (size_t n = default_hash_map_size, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0
)
: m_table (n, ggc, sanitize_eq_and_hash, gather_mem_stats,
HASH_MAP_ORIGIN )
{
}
explicit hash_map (const hash_map &h, bool ggc = false,
bool sanitize_eq_and_hash = true,
bool gather_mem_stats = 0
)
: m_table (h.m_table, ggc, sanitize_eq_and_hash, gather_mem_stats,
HASH_MAP_ORIGIN ) {}
static hash_map *create_ggc (size_t size = default_hash_map_size,
bool gather_mem_stats = 0
)
{
hash_map *map = ggc_alloc<hash_map> ();
new (map) hash_map (size, true, true, gather_mem_stats );
return map;
}
bool put (const Key &k, const Value &v)
{
hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
INSERT);
bool ins = hash_entry::is_empty (*e);
if (ins)
{
e->m_key = k;
new ((void *) &e->m_value) Value (v);
}
else
e->m_value = v;
return !ins;
}
Value *get (const Key &k)
{
hash_entry &e = m_table.find_with_hash (k, Traits::hash (k));
return Traits::is_empty (e) ? nullptr : &e.m_value;
}
Value &get_or_insert (const Key &k, bool *existed = nullptr)
{
hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
INSERT);
bool ins = Traits::is_empty (*e);
if (ins)
{
e->m_key = k;
new ((void *)&e->m_value) Value ();
}
if (existed != nullptr)
*existed = !ins;
return e->m_value;
}
void remove (const Key &k)
{
m_table.remove_elt_with_hash (k, Traits::hash (k));
}
template<typename Arg, bool (*f)(const typename Traits::key_type &,
const Value &, Arg)>
void traverse (Arg a) const
{
for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
iter != m_table.end (); ++iter)
f ((*iter).m_key, (*iter).m_value, a);
}
template<typename Arg, bool (*f)(const typename Traits::key_type &,
Value *, Arg)>
void traverse (Arg a) const
{
for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
iter != m_table.end (); ++iter)
if (!f ((*iter).m_key, &(*iter).m_value, a))
break;
}
size_t elements () const { return m_table.elements (); }
void empty () { m_table.empty(); }
bool is_empty () const { return m_table.is_empty (); }
class iterator
{
public:
explicit iterator (const typename hash_table<hash_entry>::iterator &iter) :
m_iter (iter) {}
iterator &operator++ ()
{
++m_iter;
return *this;
}
class reference_pair {
public:
const Key &first;
Value &second;
reference_pair (const Key &key, Value &value) : first (key), second (value) {}
template <typename K, typename V>
operator std::pair<K, V> () const { return std::pair<K, V> (first, second); }
};
reference_pair operator* ()
{
hash_entry &e = *m_iter;
return reference_pair (e.m_key, e.m_value);
}
bool
operator != (const iterator &other) const
{
return m_iter != other.m_iter;
}
private:
typename hash_table<hash_entry>::iterator m_iter;
};
iterator begin () const { return iterator (m_table.begin ()); }
iterator end () const { return iterator (m_table.end ()); }
private:
template<typename T, typename U, typename V> friend void gt_ggc_mx (hash_map<T, U, V> *);
template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *);
template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *, gt_pointer_operator, void *);
template<typename T, typename U, typename V> friend void gt_cleare_cache (hash_map<T, U, V> *);
hash_table<hash_entry> m_table;
};
template<typename K, typename V, typename H>
static inline void
gt_ggc_mx (hash_map<K, V, H> *h)
{
gt_ggc_mx (&h->m_table);
}
template<typename K, typename V, typename H>
static inline void
gt_pch_nx (hash_map<K, V, H> *h)
{
gt_pch_nx (&h->m_table);
}
template<typename K, typename V, typename H>
static inline void
gt_cleare_cache (hash_map<K, V, H> *h)
{
if (h)
gt_cleare_cache (&h->m_table);
}
template<typename K, typename V, typename H>
static inline void
gt_pch_nx (hash_map<K, V, H> *h, gt_pointer_operator op, void *cookie)
{
op (&h->m_table.m_entries, cookie);
}
enum hm_alloc { hm_heap = false, hm_ggc = true };
template<bool ggc, typename K, typename V, typename H>
inline hash_map<K,V,H> *
hash_map_maybe_create (hash_map<K,V,H> *&h,
size_t size = default_hash_map_size)
{
if (!h)
{
if (ggc)
h = hash_map<K,V,H>::create_ggc (size);
else
h = new hash_map<K,V,H> (size);
}
return h;
}
template<typename K, typename V, typename H>
inline V*
hash_map_safe_get (hash_map<K,V,H> *h, const K& k)
{
return h ? h->get (k) : nullptr;
}
template<bool ggc, typename K, typename V, typename H>
inline V&
hash_map_safe_get_or_insert (hash_map<K,V,H> *&h, const K& k, bool *e = nullptr,
size_t size = default_hash_map_size)
{
return hash_map_maybe_create<ggc> (h, size)->get_or_insert (k, e);
}
template<bool ggc, typename K, typename V, typename H>
inline bool
hash_map_safe_put (hash_map<K,V,H> *&h, const K& k, const V& v,
size_t size = default_hash_map_size)
{
return hash_map_maybe_create<ggc> (h, size)->put (k, v);
}
# 596 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h" 2
extern mem_alloc_description<mem_usage>& hash_table_usage (void);
extern void dump_hash_table_loc_statistics (void);
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
hash_table<Descriptor, Lazy, Allocator>::hash_table (size_t size, bool ggc,
bool sanitize_eq_and_hash,
bool gather_mem_stats
__attribute__ ((__unused__)),
mem_alloc_origin origin
) :
m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0),
m_ggc (ggc), m_sanitize_eq_and_hash (sanitize_eq_and_hash)
{
unsigned int size_prime_index;
size_prime_index = hash_table_higher_prime_index (size);
size = prime_tab[size_prime_index].prime;
if (m_gather_mem_stats)
hash_table_usage ().register_descriptor (this, origin, ggc
, 0,0,0);
if (Lazy)
m_entries = nullptr;
else
m_entries = alloc_entries (size );
m_size = size;
m_size_prime_index = size_prime_index;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
hash_table<Descriptor, Lazy, Allocator>::hash_table (const hash_table &h,
bool ggc,
bool sanitize_eq_and_hash,
bool gather_mem_stats
__attribute__ ((__unused__)),
mem_alloc_origin origin
) :
m_n_elements (h.m_n_elements), m_n_deleted (h.m_n_deleted),
m_searches (0), m_collisions (0), m_ggc (ggc),
m_sanitize_eq_and_hash (sanitize_eq_and_hash)
{
size_t size = h.m_size;
if (m_gather_mem_stats)
hash_table_usage ().register_descriptor (this, origin, ggc
, 0,0,0);
if (Lazy && h.m_entries == nullptr)
m_entries = nullptr;
else
{
value_type *nentries = alloc_entries (size );
for (size_t i = 0; i < size; ++i)
{
value_type &entry = h.m_entries[i];
if (is_deleted (entry))
mark_deleted (nentries[i]);
else if (!is_empty (entry))
new ((void*) (nentries + i)) value_type (entry);
}
m_entries = nentries;
}
m_size = size;
m_size_prime_index = h.m_size_prime_index;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
hash_table<Descriptor, Lazy, Allocator>::~hash_table ()
{
if (!Lazy || m_entries)
{
for (size_t i = m_size - 1; i < m_size; i--)
if (!is_empty (m_entries[i]) && !is_deleted (m_entries[i]))
Descriptor::remove (m_entries[i]);
if (!m_ggc)
Allocator <value_type> ::data_free (m_entries);
else
ggc_free (m_entries);
if (m_gather_mem_stats)
hash_table_usage ().release_instance_overhead (this,
sizeof (value_type)
* m_size, true);
}
else if (m_gather_mem_stats)
hash_table_usage ().unregister_descriptor (this);
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
inline typename hash_table<Descriptor, Lazy, Allocator>::value_type *
hash_table<Descriptor, Lazy,
Allocator>::alloc_entries (size_t n ) const
{
value_type *nentries;
if (m_gather_mem_stats)
hash_table_usage ().register_instance_overhead (sizeof (value_type) * n, this);
if (!m_ggc)
nentries = Allocator <value_type> ::data_alloc (n);
else
nentries = ::ggc_cleared_vec_alloc<value_type> (n );
((void)(!(nentries != nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 715, __FUNCTION__), 0 : 0));
if (!Descriptor::empty_zero_p)
for (size_t i = 0; i < n; i++)
mark_empty (nentries[i]);
return nentries;
}
# 730 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
typename hash_table<Descriptor, Lazy, Allocator>::value_type *
hash_table<Descriptor, Lazy,
Allocator>::find_empty_slot_for_expand (hashval_t hash)
{
hashval_t index = hash_table_mod1 (hash, m_size_prime_index);
size_t size = m_size;
value_type *slot = m_entries + index;
hashval_t hash2;
if (is_empty (*slot))
return slot;
((void)(!(!is_deleted (*slot)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 743, __FUNCTION__), 0 : 0));
hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
{
index += hash2;
if (index >= size)
index -= size;
slot = m_entries + index;
if (is_empty (*slot))
return slot;
((void)(!(!is_deleted (*slot)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 755, __FUNCTION__), 0 : 0));
}
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
inline bool
hash_table<Descriptor, Lazy, Allocator>::too_empty_p (unsigned int elts)
{
return elts * 8 < m_size && m_size > 32;
}
# 776 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::expand ()
{
value_type *oentries = m_entries;
unsigned int oindex = m_size_prime_index;
size_t osize = size ();
value_type *olimit = oentries + osize;
size_t elts = elements ();
unsigned int nindex;
size_t nsize;
if (elts * 2 > osize || too_empty_p (elts))
{
nindex = hash_table_higher_prime_index (elts * 2);
nsize = prime_tab[nindex].prime;
}
else
{
nindex = oindex;
nsize = osize;
}
value_type *nentries = alloc_entries (nsize);
if (m_gather_mem_stats)
hash_table_usage ().release_instance_overhead (this, sizeof (value_type)
* osize);
m_entries = nentries;
m_size = nsize;
m_size_prime_index = nindex;
m_n_elements -= m_n_deleted;
m_n_deleted = 0;
value_type *p = oentries;
do
{
value_type &x = *p;
if (!is_empty (x) && !is_deleted (x))
{
value_type *q = find_empty_slot_for_expand (Descriptor::hash (x));
new ((void*) q) value_type (x);
}
p++;
}
while (p < olimit);
if (!m_ggc)
Allocator <value_type> ::data_free (oentries);
else
ggc_free (oentries);
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::empty_slow ()
{
size_t size = m_size;
size_t nsize = size;
value_type *entries = m_entries;
for (size_t i = size - 1; i < size; i--)
if (!is_empty (entries[i]) && !is_deleted (entries[i]))
Descriptor::remove (entries[i]);
if (size > 1024*1024 / sizeof (value_type))
nsize = 1024 / sizeof (value_type);
else if (too_empty_p (m_n_elements))
nsize = m_n_elements * 2;
if (nsize != size)
{
unsigned int nindex = hash_table_higher_prime_index (nsize);
nsize = prime_tab[nindex].prime;
if (!m_ggc)
Allocator <value_type> ::data_free (m_entries);
else
ggc_free (m_entries);
m_entries = alloc_entries (nsize);
m_size = nsize;
m_size_prime_index = nindex;
}
else if (Descriptor::empty_zero_p)
memset ((void *) entries, 0, size * sizeof (value_type));
else
for (size_t i = 0; i < size; i++)
mark_empty (entries[i]);
m_n_deleted = 0;
m_n_elements = 0;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::clear_slot (value_type *slot)
{
((void)(!(!(slot < m_entries || slot >= m_entries + size () || is_empty (*slot) || is_deleted (*slot))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 890, __FUNCTION__), 0 : 0))
;
Descriptor::remove (*slot);
mark_deleted (*slot);
m_n_deleted++;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
typename hash_table<Descriptor, Lazy, Allocator>::value_type &
hash_table<Descriptor, Lazy, Allocator>
::find_with_hash (const compare_type &comparable, hashval_t hash)
{
m_searches++;
size_t size = m_size;
hashval_t index = hash_table_mod1 (hash, m_size_prime_index);
if (Lazy && m_entries == nullptr)
m_entries = alloc_entries (size);
if (m_sanitize_eq_and_hash)
verify (comparable, hash);
value_type *entry = &m_entries[index];
if (is_empty (*entry)
|| (!is_deleted (*entry) && Descriptor::equal (*entry, comparable)))
return *entry;
hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
{
m_collisions++;
index += hash2;
if (index >= size)
index -= size;
entry = &m_entries[index];
if (is_empty (*entry)
|| (!is_deleted (*entry) && Descriptor::equal (*entry, comparable)))
return *entry;
}
}
# 949 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
typename hash_table<Descriptor, Lazy, Allocator>::value_type *
hash_table<Descriptor, Lazy, Allocator>
::find_slot_with_hash (const compare_type &comparable, hashval_t hash,
enum insert_option insert)
{
if (Lazy && m_entries == nullptr)
{
if (insert == INSERT)
m_entries = alloc_entries (m_size);
else
return nullptr;
}
if (insert == INSERT && m_size * 3 <= m_n_elements * 4)
expand ();
if (m_sanitize_eq_and_hash)
verify (comparable, hash);
m_searches++;
value_type *first_deleted_slot = nullptr;
hashval_t index = hash_table_mod1 (hash, m_size_prime_index);
hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index);
value_type *entry = &m_entries[index];
size_t size = m_size;
if (is_empty (*entry))
goto empty_entry;
else if (is_deleted (*entry))
first_deleted_slot = &m_entries[index];
else if (Descriptor::equal (*entry, comparable))
return &m_entries[index];
for (;;)
{
m_collisions++;
index += hash2;
if (index >= size)
index -= size;
entry = &m_entries[index];
if (is_empty (*entry))
goto empty_entry;
else if (is_deleted (*entry))
{
if (!first_deleted_slot)
first_deleted_slot = &m_entries[index];
}
else if (Descriptor::equal (*entry, comparable))
return &m_entries[index];
}
empty_entry:
if (insert == NO_INSERT)
return nullptr;
if (first_deleted_slot)
{
m_n_deleted--;
mark_empty (*first_deleted_slot);
return first_deleted_slot;
}
m_n_elements++;
return &m_entries[index];
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>
::verify (const compare_type &comparable, hashval_t hash)
{
for (size_t i = 0; i < ((hash_table_sanitize_eq_limit) < (m_size) ? (hash_table_sanitize_eq_limit) : (m_size)); i++)
{
value_type *entry = &m_entries[i];
if (!is_empty (*entry) && !is_deleted (*entry)
&& hash != Descriptor::hash (*entry)
&& Descriptor::equal (*entry, comparable))
hashtab_chk_error ();
}
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>
::remove_elt_with_hash (const compare_type &comparable, hashval_t hash)
{
value_type *slot = find_slot_with_hash (comparable, hash, NO_INSERT);
if (slot == nullptr)
return;
Descriptor::remove (*slot);
mark_deleted (*slot);
m_n_deleted++;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
template<typename Argument,
int (*Callback)
(typename hash_table<Descriptor, Lazy, Allocator>::value_type *slot,
Argument argument)>
void
hash_table<Descriptor, Lazy, Allocator>::traverse_noresize (Argument argument)
{
if (Lazy && m_entries == nullptr)
return;
value_type *slot = m_entries;
value_type *limit = slot + size ();
do
{
value_type &x = *slot;
if (!is_empty (x) && !is_deleted (x))
if (! Callback (slot, argument))
break;
}
while (++slot < limit);
}
template <typename Descriptor, bool Lazy,
template <typename Type> class Allocator>
template <typename Argument,
int (*Callback)
(typename hash_table<Descriptor, Lazy, Allocator>::value_type *slot,
Argument argument)>
void
hash_table<Descriptor, Lazy, Allocator>::traverse (Argument argument)
{
if (too_empty_p (elements ()) && (!Lazy || m_entries))
expand ();
traverse_noresize <Argument, Callback> (argument);
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
void
hash_table<Descriptor, Lazy, Allocator>::iterator::slide ()
{
for ( ; m_slot < m_limit; ++m_slot )
{
value_type &x = *m_slot;
if (!is_empty (x) && !is_deleted (x))
return;
}
m_slot = nullptr;
m_limit = nullptr;
}
template<typename Descriptor, bool Lazy,
template<typename Type> class Allocator>
inline typename hash_table<Descriptor, Lazy, Allocator>::iterator &
hash_table<Descriptor, Lazy, Allocator>::iterator::operator ++ ()
{
++m_slot;
slide ();
return *this;
}
# 1146 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h"
template<typename E>
static inline void
gt_ggc_mx (hash_table<E> *h)
{
typedef hash_table<E> table;
if (!((h->m_entries) != nullptr && ((void *) (h->m_entries)) != (void *) 1 && ! ggc_set_mark (h->m_entries)))
return;
for (size_t i = 0; i < h->m_size; i++)
{
if (table::is_empty (h->m_entries[i])
|| table::is_deleted (h->m_entries[i]))
continue;
E::ggc_maybe_mx (h->m_entries[i]);
}
}
template<typename D>
static inline void
hashtab_entry_note_pointers (void *obj, void *h, gt_pointer_operator op,
void *cookie)
{
hash_table<D> *map = static_cast<hash_table<D> *> (h);
((void)(!(map->m_entries == obj) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 1173, __FUNCTION__), 0 : 0));
for (size_t i = 0; i < map->m_size; i++)
{
typedef hash_table<D> table;
if (table::is_empty (map->m_entries[i])
|| table::is_deleted (map->m_entries[i]))
continue;
D::pch_nx (map->m_entries[i], op, cookie);
}
}
template<typename D>
static void
gt_pch_nx (hash_table<D> *h)
{
bool success
= gt_pch_note_object (h->m_entries, h, hashtab_entry_note_pointers<D>);
((void)(!(success) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/hash-table.h", 1191, __FUNCTION__), 0 : 0));
for (size_t i = 0; i < h->m_size; i++)
{
if (hash_table<D>::is_empty (h->m_entries[i])
|| hash_table<D>::is_deleted (h->m_entries[i]))
continue;
D::pch_nx (h->m_entries[i]);
}
}
template<typename D>
static inline void
gt_pch_nx (hash_table<D> *h, gt_pointer_operator op, void *cookie)
{
op (&h->m_entries, cookie);
}
template<typename H>
inline void
gt_cleare_cache (hash_table<H> *h)
{
typedef hash_table<H> table;
if (!h)
return;
for (typename table::iterator iter = h->begin (); iter != h->end (); ++iter)
if (!table::is_empty (*iter) && !table::is_deleted (*iter))
{
int res = H::keep_cache_entry (*iter);
if (res == 0)
h->clear_slot (&*iter);
else if (res != -1)
H::ggc_mx (*iter);
}
}
# 477 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h" 1
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
template<typename KeyId, bool Lazy = false,
typename Traits = default_hash_traits<KeyId> >
class hash_set
{
public:
typedef typename Traits::value_type Key;
explicit hash_set (size_t n = 13, bool ggc = false )
: m_table (n, ggc, true, 0, HASH_SET_ORIGIN ) {}
static hash_set *
create_ggc (size_t n)
{
hash_set *set = ggc_alloc<hash_set> ();
new (set) hash_set (n, true);
return set;
}
bool add (const Key &k)
{
Key *e = m_table.find_slot_with_hash (k, Traits::hash (k), INSERT);
bool existed = !Traits::is_empty (*e);
if (!existed)
new (e) Key (k);
return existed;
}
bool contains (const Key &k)
{
if (Lazy)
return (m_table.find_slot_with_hash (k, Traits::hash (k), NO_INSERT)
!= nullptr);
Key &e = m_table.find_with_hash (k, Traits::hash (k));
return !Traits::is_empty (e);
}
void remove (const Key &k)
{
m_table.remove_elt_with_hash (k, Traits::hash (k));
}
template<typename Arg, bool (*f)(const typename Traits::value_type &, Arg)>
void traverse (Arg a) const
{
for (typename hash_table<Traits, Lazy>::iterator iter = m_table.begin ();
iter != m_table.end (); ++iter)
f (*iter, a);
}
size_t elements () const { return m_table.elements (); }
void empty () { m_table.empty (); }
bool is_empty () const { return m_table.is_empty (); }
class iterator
{
public:
explicit iterator (const typename hash_table<Traits,
Lazy>::iterator &iter) :
m_iter (iter) {}
iterator &operator++ ()
{
++m_iter;
return *this;
}
Key
operator* ()
{
return *m_iter;
}
bool
operator != (const iterator &other) const
{
return m_iter != other.m_iter;
}
private:
typename hash_table<Traits, Lazy>::iterator m_iter;
};
iterator begin () const { return iterator (m_table.begin ()); }
iterator end () const { return iterator (m_table.end ()); }
private:
template<typename T, typename U>
friend void gt_ggc_mx (hash_set<T, false, U> *);
template<typename T, typename U>
friend void gt_pch_nx (hash_set<T, false, U> *);
template<typename T, typename U>
friend void gt_pch_nx (hash_set<T, false, U> *, gt_pointer_operator, void *);
hash_table<Traits, Lazy> m_table;
};
# 161 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
template<typename T>
void
debug_helper (hash_set<T> &ref)
{
for (typename hash_set<T>::iterator it = ref.begin ();
it != ref.end (); ++it)
{
debug_slim (*it);
fputc ('\n',
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h" 3 4
stderr
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
);
}
}
# 191 "/home/giulianob/gcc_git_gnu/gcc/gcc/hash-set.h"
template<typename K, typename H>
static inline void
gt_ggc_mx (hash_set<K, false, H> *h)
{
gt_ggc_mx (&h->m_table);
}
template<typename K, typename H>
static inline void
gt_pch_nx (hash_set<K, false, H> *h)
{
gt_pch_nx (&h->m_table);
}
template<typename K, typename H>
static inline void
gt_pch_nx (hash_set<K, false, H> *h, gt_pointer_operator op, void *cookie)
{
op (&h->m_table.m_entries, cookie);
}
# 478 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h" 1
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
typedef unsigned int linenum_type;
typedef long long linenum_arith_t;
inline int compare (linenum_type lhs, linenum_type rhs)
{
linenum_arith_t diff = (linenum_arith_t)lhs - (linenum_arith_t)rhs;
if (diff)
return diff > 0 ? 1 : -1;
return 0;
}
enum lc_reason
{
LC_ENTER = 0,
LC_LEAVE,
LC_RENAME,
LC_RENAME_VERBATIM,
LC_ENTER_MACRO,
LC_HWM
};
# 291 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
typedef unsigned int location_t;
const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12);
const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000;
const location_t LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000;
const location_t LINE_MAP_MAX_LOCATION = 0x70000000;
# 319 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct source_range
{
location_t m_start;
location_t m_finish;
static source_range from_location (location_t loc)
{
source_range result;
result.m_start = loc;
result.m_finish = loc;
return result;
}
static source_range from_locations (location_t start,
location_t finish)
{
source_range result;
result.m_start = start;
result.m_finish = finish;
return result;
}
};
typedef void *(*line_map_realloc) (void *, size_t);
typedef size_t (*line_map_round_alloc_size_func) (size_t);
# 384 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct line_map {
location_t start_location;
};
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct line_map_ordinary : public line_map {
enum lc_reason reason : 8;
unsigned char sysp;
unsigned int m_column_and_range_bits : 8;
# 433 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
unsigned int m_range_bits : 8;
const char *to_file;
linenum_type to_line;
location_t included_from;
};
const location_t MAX_LOCATION_T = 0x7FFFFFFF;
struct cpp_hashnode;
struct line_map_macro : public line_map {
unsigned int n_tokens;
struct cpp_hashnode *
macro;
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t * macro_locations;
location_t expansion;
};
# 566 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
inline bool
IS_ORDINARY_LOC (location_t loc)
{
return loc < LINE_MAP_MAX_LOCATION;
}
inline bool
IS_ADHOC_LOC (location_t loc)
{
return loc > MAX_LOCATION_T;
}
inline bool
IS_MACRO_LOC (location_t loc)
{
return !IS_ORDINARY_LOC (loc) && !IS_ADHOC_LOC (loc);
}
inline bool
MAP_ORDINARY_P (const line_map *map)
{
return IS_ORDINARY_LOC (map->start_location);
}
bool
linemap_macro_expansion_map_p (const line_map *);
inline line_map_ordinary *
linemap_check_ordinary (line_map *map)
{
do { if (! (MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 604, __FUNCTION__); } while (0);
return (line_map_ordinary *)map;
}
inline const line_map_ordinary *
linemap_check_ordinary (const line_map *map)
{
do { if (! (MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 615, __FUNCTION__); } while (0);
return (const line_map_ordinary *)map;
}
inline line_map_macro *linemap_check_macro (line_map *map)
{
do { if (! (!MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 624, __FUNCTION__); } while (0);
return (line_map_macro *)map;
}
inline const line_map_macro *
linemap_check_macro (const line_map *map)
{
do { if (! (!MAP_ORDINARY_P (map))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 634, __FUNCTION__); } while (0);
return (const line_map_macro *)map;
}
inline location_t
MAP_START_LOCATION (const line_map *map)
{
return map->start_location;
}
inline linenum_type
ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map)
{
return ord_map->to_line;
}
inline unsigned char
ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map)
{
return ord_map->sysp;
}
inline const char *
ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map)
{
return ord_map->to_file;
}
inline cpp_hashnode *
MACRO_MAP_MACRO (const line_map_macro *macro_map)
{
return macro_map->macro;
}
inline unsigned int
MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map)
{
return macro_map->n_tokens;
}
inline location_t *
MACRO_MAP_LOCATIONS (const line_map_macro *macro_map)
{
return macro_map->macro_locations;
}
inline location_t
MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map)
{
return macro_map->expansion;
}
# 714 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct maps_info_ordinary {
line_map_ordinary * maps;
unsigned int allocated;
unsigned int used;
mutable unsigned int cache;
};
struct maps_info_macro {
line_map_macro * maps;
unsigned int allocated;
unsigned int used;
mutable unsigned int cache;
};
struct location_adhoc_data {
location_t locus;
source_range src_range;
void * data;
};
struct htab;
# 765 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
struct location_adhoc_data_map {
struct htab * htab;
location_t curr_loc;
unsigned int allocated;
struct location_adhoc_data *data;
};
class line_maps {
public:
~line_maps ();
maps_info_ordinary info_ordinary;
maps_info_macro info_macro;
unsigned int depth;
bool trace_includes;
location_t highest_location;
location_t highest_line;
unsigned int max_column_hint;
line_map_realloc reallocator;
line_map_round_alloc_size_func round_alloc_size;
struct location_adhoc_data_map location_adhoc_data_map;
location_t builtin_location;
bool seen_line_directive;
unsigned int default_range_bits;
unsigned int num_optimized_ranges;
unsigned int num_unoptimized_ranges;
};
inline unsigned int
LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.allocated;
else
return set->info_ordinary.allocated;
}
inline unsigned int &
LINEMAPS_ALLOCATED (line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.allocated;
else
return set->info_ordinary.allocated;
}
inline unsigned int
LINEMAPS_USED (const line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.used;
else
return set->info_ordinary.used;
}
inline unsigned int &
LINEMAPS_USED (line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.used;
else
return set->info_ordinary.used;
}
inline unsigned int &
LINEMAPS_CACHE (const line_maps *set, bool map_kind)
{
if (map_kind)
return set->info_macro.cache;
else
return set->info_ordinary.cache;
}
inline line_map *
LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index)
{
if (map_kind)
return &set->info_macro.maps[index];
else
return &set->info_ordinary.maps[index];
}
inline line_map *
LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind)
{
return LINEMAPS_MAP_AT (set, map_kind,
LINEMAPS_USED (set, map_kind) - 1);
}
inline line_map *
LINEMAPS_LAST_ALLOCATED_MAP (const line_maps *set, bool map_kind)
{
return LINEMAPS_MAP_AT (set, map_kind,
LINEMAPS_ALLOCATED (set, map_kind) - 1);
}
inline line_map_ordinary *
LINEMAPS_ORDINARY_MAPS (const line_maps *set)
{
return set->info_ordinary.maps;
}
inline line_map_ordinary *
LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index)
{
do { if (! (index >= 0 && (unsigned int)index < LINEMAPS_USED (set, false))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 919, __FUNCTION__); } while (0)
;
return (line_map_ordinary *)LINEMAPS_MAP_AT (set, false, index);
}
inline unsigned int
LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set)
{
return LINEMAPS_ALLOCATED (set, false);
}
inline unsigned int
LINEMAPS_ORDINARY_USED (const line_maps *set)
{
return LINEMAPS_USED (set, false);
}
inline unsigned int &
LINEMAPS_ORDINARY_CACHE (const line_maps *set)
{
return LINEMAPS_CACHE (set, false);
}
inline line_map_ordinary *
LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set)
{
return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false);
}
inline line_map_ordinary *
LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set)
{
return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false);
}
inline line_map_macro *
LINEMAPS_MACRO_MAPS (const line_maps *set)
{
return set->info_macro.maps;
}
inline line_map_macro *
LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index)
{
do { if (! (index >= 0 && (unsigned int)index < LINEMAPS_USED (set, true))) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 975, __FUNCTION__); } while (0)
;
return (line_map_macro *)LINEMAPS_MAP_AT (set, true, index);
}
inline unsigned int
LINEMAPS_MACRO_ALLOCATED (const line_maps *set)
{
return LINEMAPS_ALLOCATED (set, true);
}
inline unsigned int
LINEMAPS_MACRO_USED (const line_maps *set)
{
return LINEMAPS_USED (set, true);
}
inline unsigned int &
LINEMAPS_MACRO_CACHE (const line_maps *set)
{
return LINEMAPS_CACHE (set, true);
}
inline line_map_macro *
LINEMAPS_LAST_MACRO_MAP (const line_maps *set)
{
return (line_map_macro *)LINEMAPS_LAST_MAP (set, true);
}
inline location_t
LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set)
{
return LINEMAPS_MACRO_USED (set)
? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set))
: MAX_LOCATION_T + 1;
}
inline line_map_macro *
LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set)
{
return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true);
}
extern location_t get_combined_adhoc_loc (line_maps *, location_t,
source_range, void *);
extern void *get_data_from_adhoc_loc (const line_maps *, location_t);
extern location_t get_location_from_adhoc_loc (const line_maps *,
location_t);
extern source_range get_range_from_loc (line_maps *set, location_t loc);
bool
pure_location_p (line_maps *set, location_t loc);
extern location_t get_pure_location (line_maps *set, location_t loc);
inline location_t
COMBINE_LOCATION_DATA (class line_maps *set,
location_t loc,
source_range src_range,
void *block)
{
return get_combined_adhoc_loc (set, loc, src_range, block);
}
extern void rebuild_location_adhoc_htab (class line_maps *);
extern void linemap_init (class line_maps *set,
location_t builtin_location);
extern void linemap_check_files_exited (class line_maps *);
extern location_t linemap_line_start
(class line_maps *set, linenum_type to_line, unsigned int max_column_hint);
# 1092 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
extern const line_map *linemap_add
(class line_maps *, enum lc_reason, unsigned int sysp,
const char *to_file, linenum_type to_line);
extern const line_map *linemap_lookup
(const line_maps *, location_t);
bool linemap_tracks_macro_expansion_locs_p (class line_maps *);
const char* linemap_map_get_macro_name (const line_map_macro *);
# 1121 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
int linemap_location_in_system_header_p (class line_maps *,
location_t);
bool linemap_location_from_macro_expansion_p (const line_maps *,
location_t);
bool linemap_location_from_macro_definition_p (class line_maps *,
location_t);
extern location_t linemap_macro_map_loc_unwind_toward_spelling
(line_maps *set, const line_map_macro *macro_map, location_t location);
const location_t RESERVED_LOCATION_COUNT = 2;
inline linenum_type
SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc)
{
return ((loc - ord_map->start_location)
>> ord_map->m_column_and_range_bits) + ord_map->to_line;
}
inline linenum_type
SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc)
{
return ((loc - ord_map->start_location)
& ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits;
}
inline location_t
linemap_included_from (const line_map_ordinary *ord_map)
{
return ord_map->included_from;
}
const line_map_ordinary *linemap_included_from_linemap
(line_maps *set, const line_map_ordinary *map);
inline bool
MAIN_FILE_P (const line_map_ordinary *ord_map)
{
return ord_map->included_from == 0;
}
extern location_t
linemap_position_for_column (class line_maps *, unsigned int);
location_t
linemap_position_for_line_and_column (line_maps *set,
const line_map_ordinary *,
linenum_type, unsigned int);
location_t
linemap_position_for_loc_and_offset (class line_maps *set,
location_t loc,
unsigned int offset);
inline const char *
LINEMAP_FILE (const line_map_ordinary *ord_map)
{
return ord_map->to_file;
}
inline linenum_type
LINEMAP_LINE (const line_map_ordinary *ord_map)
{
return ord_map->to_line;
}
inline unsigned char
LINEMAP_SYSP (const line_map_ordinary *ord_map)
{
return ord_map->sysp;
}
int linemap_compare_locations (class line_maps *set,
location_t pre,
location_t post);
inline bool
linemap_location_before_p (class line_maps *set,
location_t loc_a,
location_t loc_b)
{
return linemap_compare_locations (set, loc_a, loc_b) >= 0;
}
typedef struct
{
const char *file;
int line;
int column;
void *data;
bool sysp;
} expanded_location;
class range_label;
# 1279 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
enum range_display_kind
{
SHOW_RANGE_WITH_CARET,
SHOW_RANGE_WITHOUT_CARET,
SHOW_LINES_WITHOUT_RANGE
};
struct location_range
{
location_t m_loc;
enum range_display_kind m_range_display_kind;
const range_label *m_label;
};
# 1320 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
template <typename T, int NUM_EMBEDDED>
class semi_embedded_vec
{
public:
semi_embedded_vec ();
~semi_embedded_vec ();
unsigned int count () const { return m_num; }
T& operator[] (int idx);
const T& operator[] (int idx) const;
void push (const T&);
void truncate (int len);
private:
int m_num;
T m_embedded[NUM_EMBEDDED];
int m_alloc;
T *m_extra;
};
template <typename T, int NUM_EMBEDDED>
semi_embedded_vec<T, NUM_EMBEDDED>::semi_embedded_vec ()
: m_num (0), m_alloc (0), m_extra (nullptr)
{
}
template <typename T, int NUM_EMBEDDED>
semi_embedded_vec<T, NUM_EMBEDDED>::~semi_embedded_vec ()
{
free ((void*) (m_extra));
}
template <typename T, int NUM_EMBEDDED>
T&
semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx)
{
do { if (! (idx < m_num)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1364, __FUNCTION__); } while (0);
if (idx < NUM_EMBEDDED)
return m_embedded[idx];
else
{
do { if (! (m_extra != nullptr)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1369, __FUNCTION__); } while (0);
return m_extra[idx - NUM_EMBEDDED];
}
}
template <typename T, int NUM_EMBEDDED>
const T&
semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) const
{
do { if (! (idx < m_num)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1380, __FUNCTION__); } while (0);
if (idx < NUM_EMBEDDED)
return m_embedded[idx];
else
{
do { if (! (m_extra != nullptr)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1385, __FUNCTION__); } while (0);
return m_extra[idx - NUM_EMBEDDED];
}
}
template <typename T, int NUM_EMBEDDED>
void
semi_embedded_vec<T, NUM_EMBEDDED>::push (const T& value)
{
int idx = m_num++;
if (idx < NUM_EMBEDDED)
m_embedded[idx] = value;
else
{
idx -= NUM_EMBEDDED;
if (nullptr == m_extra)
{
do { if (! (m_alloc == 0)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1405, __FUNCTION__); } while (0);
m_alloc = 16;
m_extra = ((T *) xmalloc (sizeof (T) * (m_alloc)));
}
else if (idx >= m_alloc)
{
do { if (! (m_alloc > 0)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1411, __FUNCTION__); } while (0);
m_alloc *= 2;
m_extra = ((T *) xrealloc ((void *) (m_extra), sizeof (T) * (m_alloc)));
}
do { if (! (m_extra)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1415, __FUNCTION__); } while (0);
do { if (! (idx < m_alloc)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1416, __FUNCTION__); } while (0);
m_extra[idx] = value;
}
}
template <typename T, int NUM_EMBEDDED>
void
semi_embedded_vec<T, NUM_EMBEDDED>::truncate (int len)
{
do { if (! (len <= m_num)) fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h", 1427, __FUNCTION__); } while (0);
m_num = len;
}
class fixit_hint;
class diagnostic_path;
# 1609 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
class rich_location
{
public:
rich_location (line_maps *set, location_t loc,
const range_label *label = nullptr);
~rich_location ();
location_t get_loc () const { return get_loc (0); }
location_t get_loc (unsigned int idx) const;
void
add_range (location_t loc,
enum range_display_kind range_display_kind
= SHOW_RANGE_WITHOUT_CARET,
const range_label *label = nullptr);
void
set_range (unsigned int idx, location_t loc,
enum range_display_kind range_display_kind);
unsigned int get_num_locations () const { return m_ranges.count (); }
const location_range *get_range (unsigned int idx) const;
location_range *get_range (unsigned int idx);
expanded_location get_expanded_location (unsigned int idx);
void
override_column (int column);
void
add_fixit_insert_before (const char *new_content);
void
add_fixit_insert_before (location_t where,
const char *new_content);
void
add_fixit_insert_after (const char *new_content);
void
add_fixit_insert_after (location_t where,
const char *new_content);
void
add_fixit_remove ();
void
add_fixit_remove (location_t where);
void
add_fixit_remove (source_range src_range);
void
add_fixit_replace (const char *new_content);
void
add_fixit_replace (location_t where,
const char *new_content);
void
add_fixit_replace (source_range src_range,
const char *new_content);
unsigned int get_num_fixit_hints () const { return m_fixit_hints.count (); }
fixit_hint *get_fixit_hint (int idx) const { return m_fixit_hints[idx]; }
fixit_hint *get_last_fixit_hint () const;
bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit; }
# 1718 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
void fixits_cannot_be_auto_applied ()
{
m_fixits_cannot_be_auto_applied = true;
}
bool fixits_can_be_auto_applied_p () const
{
return !m_fixits_cannot_be_auto_applied;
}
const diagnostic_path *get_path () const { return m_path; }
void set_path (const diagnostic_path *path) { m_path = path; }
private:
bool reject_impossible_fixit (location_t where);
void stop_supporting_fixits ();
void maybe_add_fixit (location_t start,
location_t next_loc,
const char *new_content);
public:
static const int STATICALLY_ALLOCATED_RANGES = 3;
protected:
line_maps *m_line_table;
semi_embedded_vec <location_range, STATICALLY_ALLOCATED_RANGES> m_ranges;
int m_column_override;
bool m_have_expanded_location;
expanded_location m_expanded_location;
static const int MAX_STATIC_FIXIT_HINTS = 2;
semi_embedded_vec <fixit_hint *, MAX_STATIC_FIXIT_HINTS> m_fixit_hints;
bool m_seen_impossible_fixit;
bool m_fixits_cannot_be_auto_applied;
const diagnostic_path *m_path;
};
class label_text
{
public:
label_text ()
: m_buffer (nullptr), m_caller_owned (false)
{}
void maybe_free ()
{
if (m_caller_owned)
free (m_buffer);
}
static label_text borrow (const char *buffer)
{
return label_text (const_cast <char *> (buffer), false);
}
static label_text take (char *buffer)
{
return label_text (buffer, true);
}
char *take_or_copy ()
{
if (m_caller_owned)
return m_buffer;
else
return xstrdup (m_buffer);
}
char *m_buffer;
bool m_caller_owned;
private:
label_text (char *buffer, bool owned)
: m_buffer (buffer), m_caller_owned (owned)
{}
};
# 1823 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
class range_label
{
public:
virtual ~range_label () {}
virtual label_text get_text (unsigned range_idx) const = 0;
};
# 1848 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
class fixit_hint
{
public:
fixit_hint (location_t start,
location_t next_loc,
const char *new_content);
~fixit_hint () { free (m_bytes); }
bool affects_line_p (const char *file, int line) const;
location_t get_start_loc () const { return m_start; }
location_t get_next_loc () const { return m_next_loc; }
bool maybe_append (location_t start,
location_t next_loc,
const char *new_content);
const char *get_string () const { return m_bytes; }
size_t get_length () const { return m_len; }
bool insertion_p () const { return m_start == m_next_loc; }
bool ends_with_newline_p () const;
private:
location_t m_start;
location_t m_next_loc;
char *m_bytes;
size_t m_len;
};
enum location_resolution_kind
{
LRK_MACRO_EXPANSION_POINT,
LRK_SPELLING_LOCATION,
LRK_MACRO_DEFINITION_LOCATION
};
# 1940 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t linemap_resolve_location (class line_maps *,
location_t loc,
enum location_resolution_kind lrk,
const line_map_ordinary **loc_map);
# 1952 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t linemap_unwind_toward_expansion (class line_maps *,
location_t loc,
const line_map **loc_map);
# 1970 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/line-map.h"
location_t linemap_unwind_to_first_non_reserved_loc (class line_maps *,
location_t loc,
const line_map **map);
expanded_location linemap_expand_location (class line_maps *,
const line_map *,
location_t loc);
struct linemap_stats
{
long num_ordinary_maps_allocated;
long num_ordinary_maps_used;
long ordinary_maps_allocated_size;
long ordinary_maps_used_size;
long num_expanded_macros;
long num_macro_tokens;
long num_macro_maps_used;
long macro_maps_allocated_size;
long macro_maps_used_size;
long macro_maps_locations_size;
long duplicated_macro_maps_locations_size;
long adhoc_table_size;
long adhoc_table_entries_used;
};
bool linemap_get_file_highest_location (class line_maps * set,
const char *file_name,
location_t *loc);
void linemap_get_statistics (line_maps *, struct linemap_stats *);
void linemap_dump_location (line_maps *, location_t, FILE *);
void linemap_dump (FILE *, line_maps *, unsigned, bool);
void line_table_dump (FILE *, line_maps *, unsigned int, unsigned int);
enum location_aspect
{
LOCATION_ASPECT_CARET,
LOCATION_ASPECT_START,
LOCATION_ASPECT_FINISH
};
extern expanded_location
linemap_client_expand_location_to_spelling_point (location_t,
enum location_aspect);
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h" 2
extern class line_maps *line_table;
extern class line_maps *saved_line_table;
# 37 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h"
static_assert ((((location_t) 1) < RESERVED_LOCATION_COUNT), "BUILTINS_LOCATION < RESERVED_LOCATION_COUNT");
extern bool is_location_from_builtin_token (location_t);
extern expanded_location expand_location (location_t);
extern int location_compute_display_column (expanded_location exploc,
int tabstop);
class char_span
{
public:
char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
operator bool() const { return m_ptr; }
size_t length () const { return m_n_elts; }
const char *get_buffer () const { return m_ptr; }
char operator[] (int idx) const
{
((void)(!(idx >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 64, __FUNCTION__), 0 : 0));
((void)(!((size_t)idx < m_n_elts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 65, __FUNCTION__), 0 : 0));
return m_ptr[idx];
}
char_span subspan (int offset, int n_elts) const
{
((void)(!(offset >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 71, __FUNCTION__), 0 : 0));
((void)(!(offset < (int)m_n_elts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 72, __FUNCTION__), 0 : 0));
((void)(!(n_elts >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 73, __FUNCTION__), 0 : 0));
((void)(!(offset + n_elts <= (int)m_n_elts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/input.h", 74, __FUNCTION__), 0 : 0));
return char_span (m_ptr + offset, n_elts);
}
char *xstrdup () const
{
return ::xstrndup (m_ptr, m_n_elts);
}
private:
const char *m_ptr;
size_t m_n_elts;
};
extern char_span location_get_source_line (const char *file_path, int line);
extern bool location_missing_trailing_newline (const char *file_path);
extern expanded_location
expand_location_to_spelling_point (location_t,
enum location_aspect aspect
= LOCATION_ASPECT_CARET);
extern location_t expansion_point_location_if_in_system_header (location_t);
extern location_t expansion_point_location (location_t);
extern location_t input_location;
# 122 "/home/giulianob/gcc_git_gnu/gcc/gcc/input.h"
static inline int
in_system_header_at (location_t loc)
{
return linemap_location_in_system_header_p (line_table, loc);
}
static inline bool
from_macro_expansion_at (location_t loc)
{
return linemap_location_from_macro_expansion_p (line_table, loc);
}
static inline bool
from_macro_definition_at (location_t loc)
{
return linemap_location_from_macro_definition_p (line_table, loc);
}
static inline location_t
get_pure_location (location_t loc)
{
return get_pure_location (line_table, loc);
}
static inline location_t
get_start (location_t loc)
{
return get_range_from_loc (line_table, loc).m_start;
}
static inline location_t
get_finish (location_t loc)
{
return get_range_from_loc (line_table, loc).m_finish;
}
extern location_t make_location (location_t caret,
location_t start, location_t finish);
extern location_t make_location (location_t caret, source_range src_range);
void dump_line_table_statistics (void);
void dump_location_info (FILE *stream);
void diagnostics_file_cache_fini (void);
void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
class string_concat
{
public:
string_concat (int num, location_t *locs);
int m_num;
location_t * m_locs;
};
struct location_hash : int_hash <location_t, ((location_t) 0)> { };
class string_concat_db
{
public:
string_concat_db ();
void record_string_concatenation (int num, location_t *locs);
bool get_string_concatenation (location_t loc,
int *out_num,
location_t **out_locs);
private:
static location_t get_key_loc (location_t loc);
friend void ::gt_ggc_mx_string_concat_db (void *x_p);
friend void ::gt_pch_nx_string_concat_db (void *x_p);
friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
gt_pointer_operator op,
void *cookie);
hash_map <location_hash, string_concat *> *m_table;
};
# 479 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h" 1
# 150 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h"
template <typename T>
struct is_a_helper
{
template <typename U>
static inline bool test (U *p);
template <typename U>
static inline T cast (U *p);
};
# 168 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h"
template <typename T>
template <typename U>
inline T
is_a_helper <T>::cast (U *p)
{
return reinterpret_cast <T> (p);
}
# 183 "/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h"
template <typename T, typename U>
inline bool
is_a (U *p)
{
return is_a_helper<T>::test (p);
}
template <typename T, typename U>
inline T
as_a (U *p)
{
((void)(!(is_a <T> (p)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h", 197, __FUNCTION__), 0 : 0));
return is_a_helper <T>::cast (p);
}
template <typename T, typename U>
inline T
safe_as_a (U *p)
{
if (p)
{
((void)(!(is_a <T> (p)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/is-a.h", 210, __FUNCTION__), 0 : 0));
return is_a_helper <T>::cast (p);
}
else
return nullptr;
}
template <typename T, typename U>
inline T
dyn_cast (U *p)
{
if (is_a <T> (p))
return is_a_helper <T>::cast (p);
else
return static_cast <T> (0);
}
template <typename T, typename U>
inline T
safe_dyn_cast (U *p)
{
return p ? dyn_cast <T> (p) : 0;
}
# 480 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/memory-block.h" 1
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/memory-block.h"
class memory_block_pool
{
public:
static const size_t block_size = 64 * 1024;
static const size_t freelist_size = 1024 * 1024 / block_size;
memory_block_pool ();
static inline void *allocate () __attribute__ ((__malloc__));
static inline void release (void *);
static void trim (int nblocks = freelist_size);
void reduce_free_list (int);
private:
static memory_block_pool instance;
struct block_list
{
block_list *m_next;
};
block_list *m_blocks;
};
inline void *
memory_block_pool::allocate ()
{
if (instance.m_blocks == nullptr)
return ((char *) xmalloc (sizeof (char) * (block_size)));
void *result = instance.m_blocks;
instance.m_blocks = instance.m_blocks->m_next;
;
return result;
}
inline void
memory_block_pool::release (void *uncast_block)
{
block_list *block = new (uncast_block) block_list;
block->m_next = instance.m_blocks;
instance.m_blocks = block;
;
}
extern void *mempool_obstack_chunk_alloc (size_t) __attribute__ ((__malloc__));
extern void mempool_obstack_chunk_free (void *);
# 481 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
struct function;
struct profile_count;
class sreal;
enum profile_quality {
UNINITIALIZED_PROFILE,
GUESSED_LOCAL,
GUESSED_GLOBAL0,
GUESSED_GLOBAL0_ADJUSTED,
GUESSED,
AFDO,
ADJUSTED,
PRECISE
};
extern const char *profile_quality_as_string (enum profile_quality);
extern bool parse_profile_quality (const char *value,
profile_quality *quality);
bool slow_safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res);
inline bool
safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
{
uint64_t tmp;
if (!__builtin_mul_overflow (a, b, &tmp)
&& !__builtin_add_overflow (tmp, c/2, &tmp))
{
*res = tmp / c;
return true;
}
if (c == 1)
{
*res = (uint64_t) -1;
return false;
}
# 106 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
return slow_safe_scale_64bit (a, b, c, res);
}
# 146 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
class profile_probability
{
static const int n_bits = 29;
static const uint32_t max_probability = (uint32_t) 1 << (n_bits - 2);
static const uint32_t uninitialized_probability
= ((uint32_t) 1 << (n_bits - 1)) - 1;
uint32_t m_val : 29;
enum profile_quality m_quality : 3;
friend struct profile_count;
public:
profile_probability (): m_val (uninitialized_probability),
m_quality (GUESSED)
{}
profile_probability (uint32_t val, profile_quality quality):
m_val (val), m_quality (quality)
{}
static profile_probability never ()
{
profile_probability ret;
ret.m_val = 0;
ret.m_quality = PRECISE;
return ret;
}
static profile_probability guessed_never ()
{
profile_probability ret;
ret.m_val = 0;
ret.m_quality = GUESSED;
return ret;
}
static profile_probability very_unlikely ()
{
profile_probability r = guessed_always ().apply_scale (1, 2000);
r.m_val--;
return r;
}
static profile_probability unlikely ()
{
profile_probability r = guessed_always ().apply_scale (1, 5);
r.m_val--;
return r;
}
static profile_probability even ()
{
return guessed_always ().apply_scale (1, 2);
}
static profile_probability very_likely ()
{
return always () - very_unlikely ();
}
static profile_probability likely ()
{
return always () - unlikely ();
}
static profile_probability guessed_always ()
{
profile_probability ret;
ret.m_val = max_probability;
ret.m_quality = GUESSED;
return ret;
}
static profile_probability always ()
{
profile_probability ret;
ret.m_val = max_probability;
ret.m_quality = PRECISE;
return ret;
}
static profile_probability uninitialized ()
{
profile_probability c;
c.m_val = uninitialized_probability;
c.m_quality = GUESSED;
return c;
}
bool initialized_p () const
{
return m_val != uninitialized_probability;
}
bool reliable_p () const
{
return m_quality >= ADJUSTED;
}
static profile_probability from_reg_br_prob_base (int v)
{
profile_probability ret;
((void)(!(v >= 0 && v <= 10000) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 259, __FUNCTION__), 0 : 0));
ret.m_val = (((v * (uint64_t) max_probability) + (10000) / 2) / (10000));
ret.m_quality = GUESSED;
return ret;
}
profile_probability adjusted () const
{
profile_probability ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = ADJUSTED;
return ret;
}
int to_reg_br_prob_base () const
{
((void)(!(initialized_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 277, __FUNCTION__), 0 : 0));
return (((m_val * (uint64_t) 10000) + (max_probability) / 2) / (max_probability));
}
static profile_probability from_reg_br_prob_note (int v)
{
profile_probability ret;
ret.m_val = ((unsigned int)v) / 8;
ret.m_quality = (enum profile_quality)(v & 7);
return ret;
}
int to_reg_br_prob_note () const
{
((void)(!(initialized_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 292, __FUNCTION__), 0 : 0));
int ret = m_val * 8 + m_quality;
((void)(!(from_reg_br_prob_note (ret) == *this) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 294, __FUNCTION__), 0 : 0));
return ret;
}
static profile_probability probability_in_gcov_type
(gcov_type val1, gcov_type val2)
{
profile_probability ret;
((void)(!(val1 >= 0 && val2 > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 303, __FUNCTION__), 0 : 0));
if (val1 > val2)
ret.m_val = max_probability;
else
{
uint64_t tmp;
safe_scale_64bit (val1, max_probability, val2, &tmp);
((void)(!(tmp <= max_probability) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 310, __FUNCTION__), 0 : 0));
ret.m_val = tmp;
}
ret.m_quality = PRECISE;
return ret;
}
bool operator== (const profile_probability &other) const
{
return m_val == other.m_val && m_quality == other.m_quality;
}
profile_probability operator+ (const profile_probability &other) const
{
if (other == never ())
return *this;
if (*this == never ())
return other;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
ret.m_val = (((uint32_t)(m_val + other.m_val)) < (max_probability) ? ((uint32_t)(m_val + other.m_val)) : (max_probability));
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_probability &operator+= (const profile_probability &other)
{
if (other == never ())
return *this;
if (*this == never ())
{
*this = other;
return *this;
}
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
m_val = (((uint32_t)(m_val + other.m_val)) < (max_probability) ? ((uint32_t)(m_val + other.m_val)) : (max_probability));
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
profile_probability operator- (const profile_probability &other) const
{
if (*this == never ()
|| other == never ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_probability &operator-= (const profile_probability &other)
{
if (*this == never ()
|| other == never ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
profile_probability operator* (const profile_probability &other) const
{
if (*this == never ()
|| other == never ())
return never ();
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
ret.m_val = ((((uint64_t)m_val * other.m_val) + (max_probability) / 2) / (max_probability));
ret.m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
return ret;
}
profile_probability &operator*= (const profile_probability &other)
{
if (*this == never ()
|| other == never ())
return *this = never ();
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
m_val = ((((uint64_t)m_val * other.m_val) + (max_probability) / 2) / (max_probability));
m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
}
return *this;
}
profile_probability operator/ (const profile_probability &other) const
{
if (*this == never ())
return never ();
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_probability ret;
if (m_val >= other.m_val)
{
ret.m_val = max_probability;
ret.m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (GUESSED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (GUESSED))
;
return ret;
}
else if (!m_val)
ret.m_val = 0;
else
{
((void)(!(other.m_val) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 432, __FUNCTION__), 0 : 0));
ret.m_val = ((((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) < (max_probability) ? (((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) : (max_probability))
;
}
ret.m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
return ret;
}
profile_probability &operator/= (const profile_probability &other)
{
if (*this == never ())
return *this = never ();
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
if (m_val > other.m_val)
{
m_val = max_probability;
m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (GUESSED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (GUESSED))
;
return *this;
}
else if (!m_val)
;
else
{
((void)(!(other.m_val) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 462, __FUNCTION__), 0 : 0));
m_val = ((((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) < (max_probability) ? (((((uint64_t)m_val * max_probability) + (other.m_val) / 2) / (other.m_val))) : (max_probability))
;
}
m_quality = ((((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) < (ADJUSTED) ? (((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality))) : (ADJUSTED));
}
return *this;
}
# 487 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
profile_probability split (const profile_probability &cprob)
{
profile_probability ret = *this * cprob;
if (!(*this == always ()))
*this = (*this - ret) / ret.invert ();
return ret;
}
gcov_type apply (gcov_type val) const
{
if (*this == uninitialized ())
return val / 2;
return (((val * m_val) + (max_probability) / 2) / (max_probability));
}
profile_probability invert () const
{
return always() - *this;
}
profile_probability guessed () const
{
profile_probability ret = *this;
ret.m_quality = GUESSED;
return ret;
}
profile_probability afdo () const
{
profile_probability ret = *this;
ret.m_quality = AFDO;
return ret;
}
profile_probability apply_scale (int64_t num, int64_t den) const
{
if (*this == never ())
return *this;
if (!initialized_p ())
return uninitialized ();
profile_probability ret;
uint64_t tmp;
safe_scale_64bit (m_val, num, den, &tmp);
ret.m_val = ((tmp) < (max_probability) ? (tmp) : (max_probability));
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
return ret;
}
# 560 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
bool probably_reliable_p () const
{
if (m_quality >= ADJUSTED)
return true;
if (!initialized_p ())
return false;
return m_val < max_probability / 100
|| m_val > max_probability - max_probability / 100;
}
bool verify () const
{
((void)(!(m_quality != UNINITIALIZED_PROFILE) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 573, __FUNCTION__), 0 : 0));
if (m_val == uninitialized_probability)
return m_quality == GUESSED;
else if (m_quality < GUESSED)
return false;
return m_val <= max_probability;
}
bool operator< (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val < other.m_val;
}
bool operator> (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val > other.m_val;
}
bool operator<= (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val <= other.m_val;
}
bool operator>= (const profile_probability &other) const
{
return initialized_p () && other.initialized_p () && m_val >= other.m_val;
}
uint32_t value () const { return m_val; }
enum profile_quality quality () const { return m_quality; }
void dump (FILE *f) const;
void debug () const;
bool differs_from_p (profile_probability other) const;
bool differs_lot_from_p (profile_probability other) const;
profile_probability combine_with_count (profile_count count1,
profile_probability other,
profile_count count2) const;
sreal to_sreal () const;
static profile_probability stream_in (class lto_input_block *);
void stream_out (struct output_block *);
void stream_out (struct lto_output_stream *);
};
# 690 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
struct profile_count
{
public:
static const int n_bits = 61;
static const uint64_t max_count = ((uint64_t) 1 << n_bits) - 2;
private:
static const uint64_t uninitialized_count = ((uint64_t) 1 << n_bits) - 1;
# 711 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h"
uint64_t m_val : n_bits;
enum profile_quality m_quality : 3;
public:
bool compatible_p (const profile_count other) const
{
if (!initialized_p () || !other.initialized_p ())
return true;
if (*this == zero ()
|| other == zero ())
return true;
if (ipa ().nonzero_p ()
&& !(other.ipa () == other))
return false;
if (other.ipa ().nonzero_p ()
&& !(ipa () == *this))
return false;
return ipa_p () == other.ipa_p ();
}
static profile_count zero ()
{
return from_gcov_type (0);
}
static profile_count adjusted_zero ()
{
profile_count c;
c.m_val = 0;
c.m_quality = ADJUSTED;
return c;
}
static profile_count guessed_zero ()
{
profile_count c;
c.m_val = 0;
c.m_quality = GUESSED;
return c;
}
static profile_count one ()
{
return from_gcov_type (1);
}
static profile_count uninitialized ()
{
profile_count c;
c.m_val = uninitialized_count;
c.m_quality = GUESSED_LOCAL;
return c;
}
gcov_type to_gcov_type () const
{
((void)(!(initialized_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 778, __FUNCTION__), 0 : 0));
return m_val;
}
bool initialized_p () const
{
return m_val != uninitialized_count;
}
bool reliable_p () const
{
return m_quality >= ADJUSTED;
}
bool ipa_p () const
{
return !initialized_p () || m_quality >= GUESSED_GLOBAL0;
}
bool precise_p () const
{
return m_quality == PRECISE;
}
uint32_t value () const { return m_val; }
enum profile_quality quality () const { return m_quality; }
bool ok_for_merging (profile_count other) const
{
if (m_quality < ADJUSTED
|| other.m_quality < ADJUSTED)
return true;
return !(other < *this);
}
profile_count merge (profile_count other) const
{
if (*this == other || !other.initialized_p ()
|| m_quality > other.m_quality)
return *this;
if (other.m_quality > m_quality
|| other > *this)
return other;
return *this;
}
bool operator== (const profile_count &other) const
{
return m_val == other.m_val && m_quality == other.m_quality;
}
profile_count operator+ (const profile_count &other) const
{
if (other == zero ())
return *this;
if (*this == zero ())
return other;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
profile_count ret;
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 853, __FUNCTION__), 0 : 0));
ret.m_val = m_val + other.m_val;
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_count &operator+= (const profile_count &other)
{
if (other == zero ())
return *this;
if (*this == zero ())
{
*this = other;
return *this;
}
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 872, __FUNCTION__), 0 : 0));
m_val += other.m_val;
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
profile_count operator- (const profile_count &other) const
{
if (*this == zero () || other == zero ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return uninitialized ();
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 885, __FUNCTION__), 0 : 0));
profile_count ret;
ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
ret.m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
return ret;
}
profile_count &operator-= (const profile_count &other)
{
if (*this == zero () || other == zero ())
return *this;
if (!initialized_p () || !other.initialized_p ())
return *this = uninitialized ();
else
{
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 900, __FUNCTION__), 0 : 0));
m_val = m_val >= other.m_val ? m_val - other.m_val: 0;
m_quality = ((m_quality) < (other.m_quality) ? (m_quality) : (other.m_quality));
}
return *this;
}
bool verify () const
{
((void)(!(m_quality != UNINITIALIZED_PROFILE) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 910, __FUNCTION__), 0 : 0));
return m_val != uninitialized_count || m_quality == GUESSED_LOCAL;
}
bool operator< (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (*this == zero ())
return !(other == zero ());
if (other == zero ())
return false;
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 924, __FUNCTION__), 0 : 0));
return m_val < other.m_val;
}
bool operator> (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (*this == zero ())
return false;
if (other == zero ())
return !(*this == zero ());
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 936, __FUNCTION__), 0 : 0));
return initialized_p () && other.initialized_p () && m_val > other.m_val;
}
bool operator< (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 942, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 943, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val < (uint64_t) other;
}
bool operator> (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 949, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 950, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val > (uint64_t) other;
}
bool operator<= (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (*this == zero ())
return true;
if (other == zero ())
return (*this == zero ());
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 962, __FUNCTION__), 0 : 0));
return m_val <= other.m_val;
}
bool operator>= (const profile_count &other) const
{
if (!initialized_p () || !other.initialized_p ())
return false;
if (other == zero ())
return true;
if (*this == zero ())
return (other == zero ());
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 974, __FUNCTION__), 0 : 0));
return m_val >= other.m_val;
}
bool operator<= (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 980, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 981, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val <= (uint64_t) other;
}
bool operator>= (const gcov_type other) const
{
((void)(!(ipa_p ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 987, __FUNCTION__), 0 : 0));
((void)(!(other >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 988, __FUNCTION__), 0 : 0));
return ipa ().initialized_p () && ipa ().m_val >= (uint64_t) other;
}
bool nonzero_p () const
{
return initialized_p () && m_val != 0;
}
profile_count force_nonzero () const
{
if (!initialized_p ())
return *this;
profile_count ret = *this;
if (ret.m_val == 0)
{
ret.m_val = 1;
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
}
return ret;
}
profile_count max (profile_count other) const
{
profile_count val = *this;
if (ipa ().nonzero_p () || other.ipa ().nonzero_p ())
{
val = ipa ();
other = other.ipa ();
}
if (!initialized_p ())
return other;
if (!other.initialized_p ())
return *this;
if (*this == zero ())
return other;
if (other == zero ())
return *this;
((void)(!(compatible_p (other)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1032, __FUNCTION__), 0 : 0));
if (val.m_val < other.m_val || (m_val == other.m_val
&& val.m_quality < other.m_quality))
return other;
return *this;
}
profile_count apply_probability (int prob) const
{
((void)(!(prob >= 0 && prob <= 10000) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1043, __FUNCTION__), 0 : 0));
if (m_val == 0)
return *this;
if (!initialized_p ())
return uninitialized ();
profile_count ret;
ret.m_val = (((m_val * prob) + (10000) / 2) / (10000));
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
return ret;
}
profile_count apply_probability (profile_probability prob) const
{
if (*this == zero ())
return *this;
if (prob == profile_probability::never ())
return zero ();
if (!initialized_p ())
return uninitialized ();
profile_count ret;
uint64_t tmp;
safe_scale_64bit (m_val, prob.m_val, profile_probability::max_probability,
&tmp);
ret.m_val = tmp;
ret.m_quality = ((m_quality) < (prob.m_quality) ? (m_quality) : (prob.m_quality));
return ret;
}
profile_count apply_scale (int64_t num, int64_t den) const
{
if (m_val == 0)
return *this;
if (!initialized_p ())
return uninitialized ();
profile_count ret;
uint64_t tmp;
((void)(!(num >= 0 && den > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1082, __FUNCTION__), 0 : 0));
safe_scale_64bit (m_val, num, den, &tmp);
ret.m_val = ((tmp) < (max_count) ? (tmp) : (max_count));
ret.m_quality = ((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED));
return ret;
}
profile_count apply_scale (profile_count num, profile_count den) const
{
if (*this == zero ())
return *this;
if (num == zero ())
return num;
if (!initialized_p () || !num.initialized_p () || !den.initialized_p ())
return uninitialized ();
if (num == den)
return *this;
((void)(!(den.m_val) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1099, __FUNCTION__), 0 : 0));
profile_count ret;
uint64_t val;
safe_scale_64bit (m_val, num.m_val, den.m_val, &val);
ret.m_val = ((val) < (max_count) ? (val) : (max_count));
ret.m_quality = ((((((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) < (num.m_quality) ? (((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) : (num.m_quality))) < (den.m_quality) ? (((((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) < (num.m_quality) ? (((m_quality) < (ADJUSTED) ? (m_quality) : (ADJUSTED))) : (num.m_quality))) : (den.m_quality))
;
if (num.ipa_p ())
ret.m_quality = ((ret.m_quality) > (num == num.ipa () ? GUESSED : num.m_quality) ? (ret.m_quality) : (num == num.ipa () ? GUESSED : num.m_quality))
;
return ret;
}
profile_count guessed_local () const
{
profile_count ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = GUESSED_LOCAL;
return ret;
}
profile_count global0 () const
{
profile_count ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = GUESSED_GLOBAL0;
return ret;
}
profile_count global0adjusted () const
{
profile_count ret = *this;
if (!initialized_p ())
return *this;
ret.m_quality = GUESSED_GLOBAL0_ADJUSTED;
return ret;
}
profile_count guessed () const
{
profile_count ret = *this;
ret.m_quality = ((ret.m_quality) < (GUESSED) ? (ret.m_quality) : (GUESSED));
return ret;
}
profile_count ipa () const
{
if (m_quality > GUESSED_GLOBAL0_ADJUSTED)
return *this;
if (m_quality == GUESSED_GLOBAL0)
return zero ();
if (m_quality == GUESSED_GLOBAL0_ADJUSTED)
return adjusted_zero ();
return uninitialized ();
}
profile_count afdo () const
{
profile_count ret = *this;
ret.m_quality = AFDO;
return ret;
}
profile_probability probability_in (const profile_count overall) const
{
if (*this == zero ()
&& !(overall == zero ()))
return profile_probability::never ();
if (!initialized_p () || !overall.initialized_p ()
|| !overall.m_val)
return profile_probability::uninitialized ();
if (*this == overall && m_quality == PRECISE)
return profile_probability::always ();
profile_probability ret;
((void)(!(compatible_p (overall)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h", 1188, __FUNCTION__), 0 : 0));
if (overall.m_val < m_val)
{
ret.m_val = profile_probability::max_probability;
ret.m_quality = GUESSED;
return ret;
}
else
ret.m_val = (((m_val * profile_probability::max_probability) + (overall.m_val) / 2) / (overall.m_val))
;
ret.m_quality = ((((((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) > (GUESSED) ? (((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) : (GUESSED))) < (ADJUSTED) ? (((((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) > (GUESSED) ? (((m_quality) < (overall.m_quality) ? (m_quality) : (overall.m_quality))) : (GUESSED))) : (ADJUSTED))
;
return ret;
}
int to_frequency (struct function *fun) const;
int to_cgraph_frequency (profile_count entry_bb_count) const;
sreal to_sreal_scale (profile_count in, bool *known = nullptr) const;
void dump (FILE *f) const;
void debug () const;
bool differs_from_p (profile_count other) const;
static void adjust_for_ipa_scaling (profile_count *num, profile_count *den);
profile_count combine_with_ipa_count (profile_count ipa);
profile_count combine_with_ipa_count_within
(profile_count ipa, profile_count ipa2);
static profile_count from_gcov_type (gcov_type v,
profile_quality quality = PRECISE);
static profile_count stream_in (class lto_input_block *);
void stream_out (struct output_block *);
void stream_out (struct lto_output_stream *);
};
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h" 2
# 41 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
enum tree_dump_index
{
TDI_none,
TDI_cgraph,
TDI_inheritance,
TDI_clones,
TDI_original,
TDI_gimple,
TDI_nested,
TDI_lto_stream_out,
TDI_profile_report,
TDI_lang_all,
TDI_tree_all,
TDI_rtl_all,
TDI_ipa_all,
TDI_end
};
enum dump_kind
{
DK_none,
DK_lang,
DK_tree,
DK_rtl,
DK_ipa
};
enum dump_flag
{
TDF_NONE = 0,
TDF_ADDRESS = (1 << 0),
TDF_SLIM = (1 << 1),
TDF_RAW = (1 << 2),
TDF_DETAILS = (1 << 3),
TDF_STATS = (1 << 4),
TDF_BLOCKS = (1 << 5),
TDF_VOPS = (1 << 6),
TDF_LINENO = (1 << 7),
TDF_UID = (1 << 8),
TDF_STMTADDR = (1 << 9),
TDF_GRAPH = (1 << 10),
TDF_MEMSYMS = (1 << 11),
TDF_RHS_ONLY = (1 << 12),
TDF_ASMNAME = (1 << 13),
TDF_EH = (1 << 14),
TDF_NOUID = (1 << 15),
TDF_ALIAS = (1 << 16),
TDF_ENUMERATE_LOCALS = (1 << 17),
TDF_CSELIB = (1 << 18),
TDF_SCEV = (1 << 19),
TDF_GIMPLE = (1 << 20),
TDF_FOLDING = (1 << 21),
MSG_OPTIMIZED_LOCATIONS = (1 << 22),
MSG_MISSED_OPTIMIZATION = (1 << 23),
MSG_NOTE = (1 << 24),
MSG_ALL_KINDS = (MSG_OPTIMIZED_LOCATIONS
| MSG_MISSED_OPTIMIZATION
| MSG_NOTE),
# 178 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
MSG_PRIORITY_USER_FACING = (1 << 25),
MSG_PRIORITY_INTERNALS = (1 << 26),
MSG_PRIORITY_REEMITTED = (1 << 27),
MSG_ALL_PRIORITIES = (MSG_PRIORITY_USER_FACING
| MSG_PRIORITY_INTERNALS
| MSG_PRIORITY_REEMITTED),
TDF_COMPARE_DEBUG = (1 << 28),
TDF_ERROR = (1 << 26),
TDF_ALL_VALUES = (1 << 29) - 1
};
typedef enum dump_flag dump_flags_t;
static inline dump_flags_t
operator| (dump_flags_t lhs, dump_flags_t rhs)
{
return (dump_flags_t)((int)lhs | (int)rhs);
}
static inline dump_flags_t
operator& (dump_flags_t lhs, dump_flags_t rhs)
{
return (dump_flags_t)((int)lhs & (int)rhs);
}
static inline dump_flags_t
operator~ (dump_flags_t flags)
{
return (dump_flags_t)~((int)flags);
}
static inline dump_flags_t &
operator|= (dump_flags_t &lhs, dump_flags_t rhs)
{
lhs = (dump_flags_t)((int)lhs | (int)rhs);
return lhs;
}
static inline dump_flags_t &
operator&= (dump_flags_t &lhs, dump_flags_t rhs)
{
lhs = (dump_flags_t)((int)lhs & (int)rhs);
return lhs;
}
enum optgroup_flag
{
OPTGROUP_NONE = 0,
OPTGROUP_IPA = (1 << 1),
OPTGROUP_LOOP = (1 << 2),
OPTGROUP_INLINE = (1 << 3),
OPTGROUP_OMP = (1 << 4),
OPTGROUP_VEC = (1 << 5),
OPTGROUP_OTHER = (1 << 6),
OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
| OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
};
typedef enum optgroup_flag optgroup_flags_t;
static inline optgroup_flags_t
operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
{
return (optgroup_flags_t)((int)lhs | (int)rhs);
}
static inline optgroup_flags_t &
operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
{
lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
return lhs;
}
struct dump_file_info
{
const char *suffix;
const char *swtch;
const char *glob;
const char *pfilename;
const char *alt_filename;
FILE *pstream;
FILE *alt_stream;
dump_kind dkind;
dump_flags_t pflags;
dump_flags_t alt_flags;
optgroup_flags_t optgroup_flags;
int pstate;
int alt_state;
int num;
bool owns_strings;
bool graph_dump_initialized;
};
class dump_user_location_t
{
public:
dump_user_location_t () : m_count (), m_loc (((location_t) 0)) {}
dump_user_location_t (const gimple *stmt);
dump_user_location_t (const rtx_insn *insn);
static dump_user_location_t
from_location_t (location_t loc)
{
return dump_user_location_t (profile_count (), loc);
}
static dump_user_location_t
from_function_decl (tree fndecl);
profile_count get_count () const { return m_count; }
location_t get_location_t () const { return m_loc; }
private:
dump_user_location_t (profile_count count, location_t loc)
: m_count (count), m_loc (loc)
{}
profile_count m_count;
location_t m_loc;
};
class dump_impl_location_t
{
public:
dump_impl_location_t (
const char *file = __builtin_FILE (),
int line = __builtin_LINE (),
const char *function = __builtin_FUNCTION ()
)
: m_file (file), m_line (line), m_function (function)
{}
const char *m_file;
int m_line;
const char *m_function;
};
# 404 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
class dump_metadata_t
{
public:
dump_metadata_t (dump_flags_t dump_flags,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_dump_flags (dump_flags),
m_impl_location (impl_location)
{
}
dump_flags_t get_dump_flags () const { return m_dump_flags; }
const dump_impl_location_t &
get_impl_location () const { return m_impl_location; }
private:
dump_flags_t m_dump_flags;
dump_impl_location_t m_impl_location;
};
# 436 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
class dump_location_t
{
public:
dump_location_t (const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (dump_user_location_t ()),
m_impl_location (impl_location)
{
}
dump_location_t (const gimple *stmt,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (dump_user_location_t (stmt)),
m_impl_location (impl_location)
{
}
dump_location_t (const rtx_insn *insn,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (dump_user_location_t (insn)),
m_impl_location (impl_location)
{
}
dump_location_t (const dump_user_location_t &user_location,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
: m_user_location (user_location),
m_impl_location (impl_location)
{
}
static dump_location_t
from_location_t (location_t loc,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
{
return dump_location_t (dump_user_location_t::from_location_t (loc),
impl_location);
}
const dump_user_location_t &
get_user_location () const { return m_user_location; }
const dump_impl_location_t &
get_impl_location () const { return m_impl_location; }
location_t get_location_t () const
{
return m_user_location.get_location_t ();
}
profile_count get_count () const { return m_user_location.get_count (); }
private:
dump_user_location_t m_user_location;
dump_impl_location_t m_impl_location;
};
extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
extern void dump_end (int, FILE *);
extern int opt_info_switch_p (const char *);
extern const char *dump_flag_name (int);
extern const kv_pair<optgroup_flags_t> optgroup_options[];
extern dump_flags_t
parse_dump_option (const char *, const char **);
extern FILE *dump_file;
extern dump_flags_t dump_flags;
extern const char *dump_file_name;
extern bool dumps_are_enabled;
extern void set_dump_file (FILE *new_dump_file);
static inline bool
dump_enabled_p (void)
{
return dumps_are_enabled;
}
# 563 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
extern void dump_printf (const dump_metadata_t &, const char *, ...)
__attribute__ ((__format__ (__gcc_dump_printf__, 2 ,3))) __attribute__ ((__nonnull__ (2)));
extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &,
const char *, ...)
__attribute__ ((__format__ (__gcc_dump_printf__, 3 ,0))) __attribute__ ((__nonnull__ (3)));
extern void dump_function (int phase, tree fn);
extern void dump_basic_block (dump_flags_t, basic_block, int);
extern void dump_generic_expr_loc (const dump_metadata_t &,
const dump_user_location_t &,
dump_flags_t, tree);
extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree);
extern void dump_gimple_stmt_loc (const dump_metadata_t &,
const dump_user_location_t &,
dump_flags_t, gimple *, int);
extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int);
extern void dump_gimple_expr_loc (const dump_metadata_t &,
const dump_user_location_t &,
dump_flags_t, gimple *, int);
extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int);
extern void dump_symtab_node (const dump_metadata_t &, symtab_node *);
template<unsigned int N, typename C>
void dump_dec (const dump_metadata_t &, const poly_int<N, C> &);
extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
extern void dump_hex (dump_flags_t, const poly_wide_int &);
extern void dumpfile_ensure_any_optinfo_are_flushed ();
extern unsigned int get_dump_scope_depth ();
extern void dump_begin_scope (const char *name,
const dump_user_location_t &user_location,
const dump_impl_location_t &impl_location);
extern void dump_end_scope ();
class auto_dump_scope
{
public:
auto_dump_scope (const char *name,
const dump_user_location_t &user_location,
const dump_impl_location_t &impl_location
= dump_impl_location_t ())
{
if (dump_enabled_p ())
dump_begin_scope (name, user_location, impl_location);
}
~auto_dump_scope ()
{
if (dump_enabled_p ())
dump_end_scope ();
}
};
# 640 "/home/giulianob/gcc_git_gnu/gcc/gcc/dumpfile.h"
extern void dump_function (int phase, tree fn);
extern void print_combine_total_stats (void);
extern bool enable_rtl_dump_file (void);
extern void dump_node (const_tree, dump_flags_t, FILE *);
extern void dump_combine_total_stats (FILE *);
extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
class opt_pass;
namespace gcc {
class dump_manager
{
public:
dump_manager ();
~dump_manager ();
unsigned int
dump_register (const char *suffix, const char *swtch, const char *glob,
dump_kind dkind, optgroup_flags_t optgroup_flags,
bool take_ownership);
void
register_dumps ();
struct dump_file_info *
get_dump_file_info (int phase) const;
struct dump_file_info *
get_dump_file_info_by_switch (const char *swtch) const;
char *
get_dump_file_name (int phase, int part = -1) const;
char *
get_dump_file_name (struct dump_file_info *dfi, int part = -1) const;
void
dump_switch_p (const char *arg);
int
dump_start (int phase, dump_flags_t *flag_ptr);
void
dump_finish (int phase);
FILE *
dump_begin (int phase, dump_flags_t *flag_ptr, int part);
int
dump_initialized_p (int phase) const;
const char *
dump_flag_name (int phase) const;
void register_pass (opt_pass *pass);
private:
int
dump_phase_enabled_p (int phase) const;
int
dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob);
int
dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
int
opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
const char *filename);
bool update_dfi_for_opt_info (dump_file_info *dfi) const;
private:
int m_next_dump;
struct dump_file_info *m_extra_dump_files;
size_t m_extra_dump_files_in_use;
size_t m_extra_dump_files_alloced;
optgroup_flags_t m_optgroup_flags;
dump_flags_t m_optinfo_flags;
char *m_optinfo_filename;
friend bool ::enable_rtl_dump_file (void);
friend int ::opt_info_switch_p (const char *arg);
};
}
# 482 "/home/giulianob/gcc_git_gnu/gcc/gcc/coretypes.h" 2
# 96 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h"
# 1 "./tm.h" 1
# 22 "./tm.h"
# 1 "./options.h" 1
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum debug_info_type
{
NO_DEBUG,
DBX_DEBUG,
DWARF2_DEBUG,
XCOFF_DEBUG,
VMS_DEBUG,
VMS_AND_DWARF2_DEBUG
};
enum debug_info_levels
{
DINFO_LEVEL_NONE,
DINFO_LEVEL_TERSE,
DINFO_LEVEL_NORMAL,
DINFO_LEVEL_VERBOSE
};
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum debug_info_usage
{
DINFO_USAGE_DFN,
DINFO_USAGE_DIR_USE,
DINFO_USAGE_IND_USE,
DINFO_USAGE_NUM_ENUMS
};
# 83 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum debug_struct_file
{
DINFO_STRUCT_FILE_NONE,
DINFO_STRUCT_FILE_BASE,
DINFO_STRUCT_FILE_SYS,
DINFO_STRUCT_FILE_ANY
};
enum dwarf_gnat_encodings
{
DWARF_GNAT_ENCODINGS_ALL = 0,
DWARF_GNAT_ENCODINGS_GDB = 1,
DWARF_GNAT_ENCODINGS_MINIMAL = 2
};
enum ivar_visibility
{
IVAR_VISIBILITY_PRIVATE,
IVAR_VISIBILITY_PROTECTED,
IVAR_VISIBILITY_PUBLIC,
IVAR_VISIBILITY_PACKAGE
};
enum stack_reuse_level
{
SR_NONE,
SR_NAMED_VARS,
SR_ALL
};
enum live_patching_level
{
LIVE_PATCHING_NONE = 0,
LIVE_PATCHING_INLINE_ONLY_STATIC,
LIVE_PATCHING_INLINE_CLONE
};
enum reorder_blocks_algorithm
{
REORDER_BLOCKS_ALGORITHM_SIMPLE,
REORDER_BLOCKS_ALGORITHM_STC
};
enum ira_algorithm
{
IRA_ALGORITHM_CB,
IRA_ALGORITHM_PRIORITY
};
enum ira_region
{
IRA_REGION_ONE,
IRA_REGION_ALL,
IRA_REGION_MIXED,
IRA_REGION_AUTODETECT
};
enum excess_precision
{
EXCESS_PRECISION_DEFAULT,
EXCESS_PRECISION_FAST,
EXCESS_PRECISION_STANDARD
};
enum permitted_flt_eval_methods
{
PERMITTED_FLT_EVAL_METHODS_DEFAULT,
PERMITTED_FLT_EVAL_METHODS_TS_18661,
PERMITTED_FLT_EVAL_METHODS_C11
};
# 184 "/home/giulianob/gcc_git_gnu/gcc/gcc/flag-types.h"
enum stack_check_type
{
NO_STACK_CHECK = 0,
GENERIC_STACK_CHECK,
STATIC_BUILTIN_STACK_CHECK,
FULL_BUILTIN_STACK_CHECK
};
enum callgraph_info_type
{
NO_CALLGRAPH_INFO = 0,
CALLGRAPH_INFO_NAKED = 1,
CALLGRAPH_INFO_STACK_USAGE = 2,
CALLGRAPH_INFO_DYNAMIC_ALLOC = 4
};
enum fp_contract_mode {
FP_CONTRACT_OFF = 0,
FP_CONTRACT_ON = 1,
FP_CONTRACT_FAST = 2
};
enum scalar_storage_order_kind {
SSO_NATIVE = 0,
SSO_BIG_ENDIAN,
SSO_LITTLE_ENDIAN
};
enum vect_cost_model {
VECT_COST_MODEL_UNLIMITED = 0,
VECT_COST_MODEL_CHEAP = 1,
VECT_COST_MODEL_DYNAMIC = 2,
VECT_COST_MODEL_DEFAULT = 3
};
enum sanitize_code {
SANITIZE_ADDRESS = 1UL << 0,
SANITIZE_USER_ADDRESS = 1UL << 1,
SANITIZE_KERNEL_ADDRESS = 1UL << 2,
SANITIZE_THREAD = 1UL << 3,
SANITIZE_LEAK = 1UL << 4,
SANITIZE_SHIFT_BASE = 1UL << 5,
SANITIZE_SHIFT_EXPONENT = 1UL << 6,
SANITIZE_DIVIDE = 1UL << 7,
SANITIZE_UNREACHABLE = 1UL << 8,
SANITIZE_VLA = 1UL << 9,
SANITIZE_NULL = 1UL << 10,
SANITIZE_RETURN = 1UL << 11,
SANITIZE_SI_OVERFLOW = 1UL << 12,
SANITIZE_BOOL = 1UL << 13,
SANITIZE_ENUM = 1UL << 14,
SANITIZE_FLOAT_DIVIDE = 1UL << 15,
SANITIZE_FLOAT_CAST = 1UL << 16,
SANITIZE_BOUNDS = 1UL << 17,
SANITIZE_ALIGNMENT = 1UL << 18,
SANITIZE_NONNULL_ATTRIBUTE = 1UL << 19,
SANITIZE_RETURNS_NONNULL_ATTRIBUTE = 1UL << 20,
SANITIZE_OBJECT_SIZE = 1UL << 21,
SANITIZE_VPTR = 1UL << 22,
SANITIZE_BOUNDS_STRICT = 1UL << 23,
SANITIZE_POINTER_OVERFLOW = 1UL << 24,
SANITIZE_BUILTIN = 1UL << 25,
SANITIZE_POINTER_COMPARE = 1UL << 26,
SANITIZE_POINTER_SUBTRACT = 1UL << 27,
SANITIZE_SHIFT = SANITIZE_SHIFT_BASE | SANITIZE_SHIFT_EXPONENT,
SANITIZE_UNDEFINED = SANITIZE_SHIFT | SANITIZE_DIVIDE | SANITIZE_UNREACHABLE
| SANITIZE_VLA | SANITIZE_NULL | SANITIZE_RETURN
| SANITIZE_SI_OVERFLOW | SANITIZE_BOOL | SANITIZE_ENUM
| SANITIZE_BOUNDS | SANITIZE_ALIGNMENT
| SANITIZE_NONNULL_ATTRIBUTE
| SANITIZE_RETURNS_NONNULL_ATTRIBUTE
| SANITIZE_OBJECT_SIZE | SANITIZE_VPTR
| SANITIZE_POINTER_OVERFLOW | SANITIZE_BUILTIN,
SANITIZE_UNDEFINED_NONDEFAULT = SANITIZE_FLOAT_DIVIDE | SANITIZE_FLOAT_CAST
| SANITIZE_BOUNDS_STRICT
};
enum incremental_link {
INCREMENTAL_LINK_NONE,
INCREMENTAL_LINK_NOLTO,
INCREMENTAL_LINK_LTO
};
enum sanitize_coverage_code {
SANITIZE_COV_TRACE_PC = 1 << 0,
SANITIZE_COV_TRACE_CMP = 1 << 1
};
enum vtv_priority {
VTV_NO_PRIORITY = 0,
VTV_STANDARD_PRIORITY = 1,
VTV_PREINIT_PRIORITY = 2
};
enum lto_partition_model {
LTO_PARTITION_NONE = 0,
LTO_PARTITION_ONE = 1,
LTO_PARTITION_BALANCED = 2,
LTO_PARTITION_1TO1 = 3,
LTO_PARTITION_MAX = 4
};
enum lto_linker_output {
LTO_LINKER_OUTPUT_UNKNOWN,
LTO_LINKER_OUTPUT_REL,
LTO_LINKER_OUTPUT_NOLTOREL,
LTO_LINKER_OUTPUT_DYN,
LTO_LINKER_OUTPUT_PIE,
LTO_LINKER_OUTPUT_EXEC
};
enum gfc_init_local_real
{
GFC_INIT_REAL_OFF = 0,
GFC_INIT_REAL_ZERO,
GFC_INIT_REAL_NAN,
GFC_INIT_REAL_SNAN,
GFC_INIT_REAL_INF,
GFC_INIT_REAL_NEG_INF
};
enum gfc_fcoarray
{
GFC_FCOARRAY_NONE = 0,
GFC_FCOARRAY_SINGLE,
GFC_FCOARRAY_LIB
};
enum gfc_convert
{
GFC_FLAG_CONVERT_NATIVE = 0,
GFC_FLAG_CONVERT_SWAP,
GFC_FLAG_CONVERT_BIG,
GFC_FLAG_CONVERT_LITTLE
};
enum cf_protection_level
{
CF_NONE = 0,
CF_BRANCH = 1 << 0,
CF_RETURN = 1 << 1,
CF_FULL = CF_BRANCH | CF_RETURN,
CF_SET = 1 << 2,
CF_CHECK = 1 << 3
};
enum parloops_schedule_type
{
PARLOOPS_SCHEDULE_STATIC = 0,
PARLOOPS_SCHEDULE_DYNAMIC,
PARLOOPS_SCHEDULE_GUIDED,
PARLOOPS_SCHEDULE_AUTO,
PARLOOPS_SCHEDULE_RUNTIME
};
# 7 "./options.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386-opts.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386-opts.h"
enum stringop_alg
{
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/stringop.def" 1
# 20 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/stringop.def"
no_stringop,
libcall,
rep_prefix_1_byte,
rep_prefix_4_byte,
rep_prefix_8_byte,
loop_1_byte,
loop,
unrolled_loop,
vector_loop,
# 38 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386-opts.h" 2
last_alg
};
enum calling_abi
{
SYSV_ABI = 0,
MS_ABI = 1
};
enum fpmath_unit
{
FPMATH_387 = 1,
FPMATH_SSE = 2
};
enum tls_dialect
{
TLS_DIALECT_GNU,
TLS_DIALECT_GNU2,
TLS_DIALECT_SUN
};
enum cmodel {
CM_32,
CM_SMALL,
CM_KERNEL,
CM_MEDIUM,
CM_LARGE,
CM_SMALL_PIC,
CM_MEDIUM_PIC,
CM_LARGE_PIC
};
enum pmode {
PMODE_SI,
PMODE_DI
};
enum ix86_align_data {
ix86_align_data_type_compat,
ix86_align_data_type_abi,
ix86_align_data_type_cacheline
};
enum asm_dialect {
ASM_ATT,
ASM_INTEL
};
enum ix86_veclibabi {
ix86_veclibabi_type_none,
ix86_veclibabi_type_svml,
ix86_veclibabi_type_acml
};
enum stack_protector_guard {
SSP_TLS,
SSP_GLOBAL
};
enum prefer_vector_width {
PVW_NONE,
PVW_AVX128,
PVW_AVX256,
PVW_AVX512
};
enum indirect_branch {
indirect_branch_unset = 0,
indirect_branch_keep,
indirect_branch_thunk,
indirect_branch_thunk_inline,
indirect_branch_thunk_extern
};
enum instrument_return {
instrument_return_none = 0,
instrument_return_call,
instrument_return_nop5
};
# 9 "./options.h" 2
struct gcc_options
{
long x_ix86_stack_protector_guard_offset;
addr_space_t x_ix86_stack_protector_guard_reg;
int x_recip_mask;
long x_function_entry_patch_area_size;
long x_function_entry_patch_area_start;
long x_ix86_isa_flags;
long x_ix86_isa_flags2;
long x_ix86_isa_flags2_explicit;
long x_ix86_isa_flags_explicit;
bool x_dump_base_name_prefixed;
bool x_exit_after_options;
bool x_flag_disable_hsa;
bool x_flag_dump_all_passed;
bool x_flag_opts_finished;
bool x_flag_stack_usage_info;
bool x_flag_warn_unused_result;
bool x_in_lto_p;
bool x_use_gnu_debug_info_extensions;
char * x_help_enum_printed;
char * x_help_printed;
const char * x_aux_base_name;
const char * x_flag_parallel_jobs;
const char * x_main_input_basename;
const char * x_main_input_filename;
const char * x_split_outputs;
enum debug_info_levels x_debug_info_level;
enum debug_info_type x_write_symbols;
enum debug_struct_file x_debug_struct_generic[DINFO_USAGE_NUM_ENUMS];
enum debug_struct_file x_debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS];
enum dwarf_gnat_encodings x_gnat_encodings;
enum incremental_link x_flag_incremental_link;
enum stack_check_type x_flag_stack_check;
int x_flag_complex_method;
int x_flag_debug_asm;
int x_flag_dump_rtl_in_asm;
int x_flag_gen_aux_info;
int x_flag_generate_lto;
int x_flag_generate_offload;
int x_flag_print_asm_name;
int x_flag_shlib;
int x_ix86_target_flags;
int x_main_input_baselength;
int x_optimize;
int x_optimize_debug;
int x_optimize_fast;
int x_optimize_size;
int x_recip_mask_explicit;
int x_rtl_dump_and_exit;
int x_target_flags;
unsigned int x_flag_sanitize;
unsigned int x_flag_sanitize_coverage;
unsigned int x_flag_sanitize_recover;
unsigned int x_help_columns;
unsigned int x_initial_max_fld_align;
void * x_flag_instrument_functions_exclude_files;
void * x_flag_instrument_functions_exclude_functions;
int x_help_flag;
int x_no_sysroot_suffix;
int x_param_align_loop_iterations;
int x_param_align_threshold;
int x_param_analyzer_bb_explosion_factor;
int x_param_analyzer_max_enodes_for_full_dump;
int x_param_analyzer_max_enodes_per_program_point;
int x_param_analyzer_max_recursion_depth;
int x_param_analyzer_max_svalue_depth;
int x_param_analyzer_min_snodes_for_call_summary;
int x_param_asan_globals;
int x_param_asan_protect_allocas;
int x_param_asan_instrument_reads;
int x_param_asan_instrument_writes;
int x_param_asan_instrumentation_with_call_threshold;
int x_param_asan_memintrin;
int x_param_asan_stack;
int x_param_asan_use_after_return;
int x_param_avg_loop_niter;
int x_param_avoid_fma_max_bits;
int x_param_balance_partitions;
int x_param_builtin_expect_probability;
int x_param_builtin_string_cmp_inline_length;
int x_param_case_values_threshold;
int x_param_comdat_sharing_probability;
int x_param_cxx_max_namespaces_for_diagnostic_help;
int x_param_dse_max_alias_queries_per_store;
int x_param_dse_max_object_size;
int x_param_early_inlining_insns;
int x_param_fsm_maximum_phi_arguments;
int x_param_fsm_scale_path_blocks;
int x_param_fsm_scale_path_stmts;
int x_param_gcse_after_reload_critical_fraction;
int x_param_gcse_after_reload_partial_fraction;
int x_param_gcse_cost_distance_ratio;
int x_param_gcse_unrestricted_cost;
int x_param_ggc_min_expand;
int x_param_ggc_min_heapsize;
int x_param_gimple_fe_computed_hot_bb_threshold;
int x_param_graphite_allow_codegen_errors;
int x_param_graphite_max_arrays_per_scop;
int x_param_graphite_max_nb_scop_params;
int x_param_hash_table_verification_limit;
int x_param_hot_bb_count_fraction;
int x_param_hot_bb_count_ws_permille;
int x_param_hot_bb_frequency_fraction;
int x_param_inline_heuristics_hint_percent;
int x_param_inline_min_speedup;
int x_param_inline_unit_growth;
int x_param_integer_share_limit;
int x_param_ipa_cp_eval_threshold;
int x_param_ipa_cp_loop_hint_bonus;
int x_param_ipa_cp_max_recursive_depth;
int x_param_ipa_cp_min_recursive_probability;
int x_param_ipa_cp_recursion_penalty;
int x_param_ipa_cp_single_call_penalty;
int x_param_ipa_cp_unit_growth;
int x_param_ipa_cp_value_list_size;
int x_param_ipa_max_aa_steps;
int x_param_ipa_max_agg_items;
int x_param_ipa_max_param_expr_ops;
int x_param_ipa_max_switch_predicate_bounds;
int x_param_ipa_sra_max_replacements;
int x_param_ipa_sra_ptr_growth_factor;
int x_param_ira_loop_reserved_regs;
int x_param_ira_max_conflict_table_size;
int x_param_ira_max_loops_num;
int x_param_iv_always_prune_cand_set_bound;
int x_param_iv_consider_all_candidates_bound;
int x_param_iv_max_considered_uses;
int x_param_jump_table_max_growth_ratio_for_size;
int x_param_jump_table_max_growth_ratio_for_speed;
int x_param_l1_cache_line_size;
int x_param_l1_cache_size;
int x_param_l2_cache_size;
int x_param_large_function_growth;
int x_param_large_function_insns;
int x_param_stack_frame_growth;
int x_param_large_stack_frame;
int x_param_large_unit_insns;
int x_param_lim_expensive;
int x_param_logical_op_non_short_circuit;
int x_param_loop_block_tile_size;
int x_param_loop_interchange_max_num_stmts;
int x_param_loop_interchange_stride_ratio;
int x_param_loop_invariant_max_bbs_in_loop;
int x_param_loop_max_datarefs_for_datadeps;
int x_param_loop_versioning_max_inner_insns;
int x_param_loop_versioning_max_outer_insns;
int x_param_lra_inheritance_ebb_probability_cutoff;
int x_param_lra_max_considered_reload_pseudos;
int x_param_max_partition_size;
int x_param_max_lto_streaming_parallelism;
int x_param_min_partition_size;
int x_param_lto_partitions;
int x_param_max_average_unrolled_insns;
int x_param_max_combine_insns;
int x_param_max_unroll_iterations;
int x_param_max_completely_peel_times;
int x_param_max_completely_peeled_insns;
int x_param_max_crossjump_edges;
int x_param_max_cse_insns;
int x_param_max_cse_path_length;
int x_param_max_cselib_memory_locations;
int x_param_max_debug_marker_count;
int x_param_max_delay_slot_insn_search;
int x_param_max_delay_slot_live_search;
int x_param_max_dse_active_local_stores;
int x_param_early_inliner_max_iterations;
int x_param_max_fields_for_field_sensitive;
int x_param_max_find_base_term_values;
int x_param_max_fsm_thread_length;
int x_param_max_fsm_thread_path_insns;
int x_param_max_fsm_thread_paths;
int x_param_max_gcse_insertion_ratio;
int x_param_max_gcse_memory;
int x_param_max_goto_duplication_insns;
int x_param_max_grow_copy_bb_insns;
int x_param_max_hoist_depth;
int x_param_max_inline_insns_auto;
int x_param_max_inline_insns_recursive_auto;
int x_param_max_inline_insns_recursive;
int x_param_max_inline_insns_single;
int x_param_max_inline_insns_size;
int x_param_max_inline_insns_small;
int x_param_max_inline_recursive_depth_auto;
int x_param_max_inline_recursive_depth;
int x_param_max_isl_operations;
int x_param_max_iterations_computation_cost;
int x_param_max_iterations_to_track;
int x_param_max_jump_thread_duplication_stmts;
int x_param_max_last_value_rtl;
int x_param_max_loop_header_insns;
int x_param_max_modulo_backtrack_attempts;
int x_param_max_partial_antic_length;
int x_param_max_peel_branches;
int x_param_max_peel_times;
int x_param_max_peeled_insns;
int x_param_max_pending_list_length;
int x_param_max_pipeline_region_blocks;
int x_param_max_pipeline_region_insns;
int x_param_max_pow_sqrt_depth;
int x_param_max_predicted_iterations;
int x_param_max_reload_search_insns;
int x_param_max_rtl_if_conversion_insns;
int x_param_max_rtl_if_conversion_predictable_cost;
int x_param_max_rtl_if_conversion_unpredictable_cost;
int x_param_max_sched_extend_regions_iters;
int x_param_max_sched_insn_conflict_delay;
int x_param_max_sched_ready_insns;
int x_param_max_sched_region_blocks;
int x_param_max_sched_region_insns;
int x_param_max_slsr_candidate_scan;
int x_param_max_speculative_devirt_maydefs;
int x_param_max_ssa_name_query_depth;
int x_param_max_stores_to_merge;
int x_param_max_stores_to_sink;
int x_param_max_tail_merge_comparisons;
int x_param_max_tail_merge_iterations;
int x_param_max_tracked_strlens;
int x_param_max_tree_if_conversion_phi_args;
int x_param_max_unroll_times;
int x_param_max_unrolled_insns;
int x_param_max_unswitch_insns;
int x_param_max_unswitch_level;
int x_param_max_variable_expansions;
int x_param_max_vartrack_expr_depth;
int x_param_max_vartrack_reverse_op_size;
int x_param_max_vartrack_size;
int x_param_max_vrp_switch_assertions;
int x_param_min_crossjump_insns;
int x_param_min_inline_recursive_probability;
int x_param_min_insn_to_prefetch_ratio;
int x_param_min_loop_cond_split_prob;
int x_param_min_nondebug_insn_uid;
int x_param_min_size_for_stack_sharing;
int x_param_min_spec_prob;
int x_param_min_vect_loop_bound;
int x_param_parloops_chunk_size;
int x_param_parloops_min_per_thread;
int x_param_parloops_schedule;
int x_param_partial_inlining_entry_probability;
int x_param_predictable_branch_outcome;
int x_param_prefetch_dynamic_strides;
int x_param_prefetch_latency;
int x_param_prefetch_min_insn_to_mem_ratio;
int x_param_prefetch_minimum_stride;
int x_param_profile_func_internal_id;
int x_param_promote_statics;
int x_param_rpo_vn_max_loop_depth;
int x_param_sccvn_max_alias_queries_per_access;
int x_param_scev_max_expr_complexity;
int x_param_scev_max_expr_size;
int x_param_sched_autopref_queue_depth;
int x_param_sched_mem_true_dep_cost;
int x_param_sched_pressure_algorithm;
int x_param_sched_spec_prob_cutoff;
int x_param_sched_state_edge_prob_cutoff;
int x_param_selsched_insns_to_rename;
int x_param_selsched_max_lookahead;
int x_param_selsched_max_sched_times;
int x_param_simultaneous_prefetches;
int x_param_sink_frequency_threshold;
int x_param_slp_max_insns_in_bb;
int x_param_sms_dfa_history;
int x_param_sms_loop_average_count_threshold;
int x_param_sms_max_ii_factor;
int x_param_sms_min_sc;
int x_param_sra_max_propagations;
int x_param_sra_max_scalarization_size_size;
int x_param_sra_max_scalarization_size_speed;
int x_param_ssa_name_def_chain_limit;
int x_param_ssp_buffer_size;
int x_param_stack_clash_protection_guard_size;
int x_param_stack_clash_protection_probe_interval;
int x_param_store_merging_allow_unaligned;
int x_param_store_merging_max_size;
int x_param_switch_conversion_branch_ratio;
int x_param_tm_max_aggregate_size;
int x_param_tracer_dynamic_coverage_feedback;
int x_param_tracer_dynamic_coverage;
int x_param_tracer_max_code_growth;
int x_param_tracer_min_branch_probability_feedback;
int x_param_tracer_min_branch_probability;
int x_param_tracer_min_branch_ratio;
int x_param_tree_reassoc_width;
int x_param_tsan_distinguish_volatile;
int x_param_tsan_instrument_func_entry_exit;
int x_param_uninit_control_dep_attempts;
int x_param_uninlined_function_insns;
int x_param_uninlined_function_time;
int x_param_uninlined_function_thunk_insns;
int x_param_uninlined_function_thunk_time;
int x_param_unlikely_bb_count_fraction;
int x_param_unroll_jam_max_unroll;
int x_param_unroll_jam_min_percent;
int x_param_use_after_scope_direct_emission_threshold;
int x_param_use_canonical_types;
int x_param_vect_epilogues_nomask;
int x_param_vect_max_peeling_for_alignment;
int x_param_vect_max_version_for_alias_checks;
int x_param_vect_max_version_for_alignment_checks;
int x_param_vect_partial_vector_usage;
int x_flag_preprocess_only;
int x_warn_abi;
int x_warn_abi_tag;
int x_warn_absolute_value;
int x_warn_address;
int x_warn_address_of_packed_member;
int x_warn_aggregate_return;
int x_warn_aggressive_loop_optimizations;
int x_warn_aliasing;
int x_warn_align_commons;
int x_warn_aligned_new;
long x_warn_alloc_size_limit;
int x_warn_alloc_zero;
int x_warn_alloca;
long x_warn_alloca_limit;
int x_warn_ampersand;
int x_warn_analyzer_double_fclose;
int x_warn_analyzer_double_free;
int x_warn_analyzer_exposure_through_output_file;
int x_warn_analyzer_file_leak;
int x_warn_analyzer_free_of_non_heap;
int x_warn_analyzer_malloc_leak;
int x_warn_analyzer_null_argument;
int x_warn_analyzer_null_dereference;
int x_warn_analyzer_possible_null_argument;
int x_warn_analyzer_possible_null_dereference;
int x_warn_analyzer_stale_setjmp_buffer;
int x_warn_analyzer_tainted_array_index;
int x_warn_analyzer_too_complex;
int x_warn_analyzer_unsafe_call_within_signal_handler;
int x_warn_analyzer_use_after_free;
int x_warn_analyzer_use_of_pointer_in_stale_stack_frame;
int x_warn_arith_conv;
int x_warn_array_bounds;
int x_warn_array_temporaries;
int x_warn_assign_intercept;
int x_warn_attribute_alias;
int x_warn_attribute_warning;
int x_warn_attributes;
int x_warn_bad_function_cast;
int x_warn_bool_compare;
int x_warn_bool_op;
int x_warn_builtin_declaraion_mismatch;
int x_cpp_warn_builtin_macro_redefined;
int x_warn_cxx_compat;
int x_warn_cxx11_compat;
int x_warn_cxx14_compat;
int x_warn_cxx17_compat;
int x_warn_cxx20_compat;
int x_warn_c_binding_type;
int x_warn_c11_c2x_compat;
int x_warn_c90_c99_compat;
int x_warn_c99_c11_compat;
int x_warn_cannot_profile;
int x_warn_cast_align;
int x_warn_cast_function_type;
int x_warn_cast_qual;
int x_warn_cast_result;
int x_warn_catch_value;
int x_warn_char_subscripts;
int x_warn_character_truncation;
int x_warn_class_conversion;
int x_warn_class_memaccess;
int x_warn_clobbered;
int x_warn_comma_subscript;
int x_cpp_warn_comment;
int x_warn_compare_reals;
int x_warn_conditionally_supported;
int x_warn_conversion;
int x_warn_conversion_extra;
int x_warn_conversion_null;
int x_warn_coverage_mismatch;
int x_warn_cpp;
int x_warn_ctor_dtor_privacy;
int x_warn_dangling_else;
int x_cpp_warn_date_time;
int x_warn_declaration_after_statement;
int x_warn_delete_incomplete;
int x_warn_delnonvdtor;
int x_warn_deprecated;
int x_warn_deprecated_copy;
int x_warn_deprecated_decl;
int x_warn_designated_init;
int x_warn_disabled_optimization;
int x_warn_discarded_array_qualifiers;
int x_warn_discarded_qualifiers;
int x_warn_div_by_zero;
int x_warn_do_subscript;
int x_warn_double_promotion;
int x_warn_duplicate_decl_specifier;
int x_warn_duplicated_branches;
int x_warn_duplicated_cond;
int x_warn_ecpp;
int x_warn_empty_body;
int x_cpp_warn_endif_labels;
int x_warn_enum_compare;
int x_warn_enum_conversion;
int x_warnings_are_errors;
int x_cpp_warn_expansion_to_defined;
int x_extra_warnings;
int x_warn_extra_semi;
int x_flag_fatal_errors;
int x_warn_float_conversion;
int x_warn_float_equal;
int x_warn_format_contains_nul;
int x_warn_format_diag;
int x_warn_format_extra_args;
int x_warn_format_nonliteral;
int x_warn_format_overflow;
int x_warn_format_security;
int x_warn_format_signedness;
int x_warn_format_trunc;
int x_warn_format_y2k;
int x_warn_format_zero_length;
int x_warn_format;
int x_warn_frame_address;
long x_warn_frame_larger_than_size;
int x_warn_free_nonheap_object;
int x_flag_warn_frontend_loop_interchange;
int x_warn_function_elimination;
int x_warn_if_not_aligned;
int x_warn_ignored_attributes;
int x_warn_ignored_qualifiers;
int x_warn_implicit;
int x_warn_implicit_fallthrough;
int x_warn_implicit_function_declaration;
int x_warn_implicit_int;
int x_warn_implicit_interface;
int x_warn_implicit_procedure;
int x_warn_inaccessible_base;
int x_warn_incompatible_pointer_types;
int x_warn_inh_var_ctor;
int x_warn_init_list;
int x_warn_init_self;
int x_warn_inline;
int x_warn_int_conversion;
int x_warn_int_in_bool_context;
int x_warn_int_to_pointer_cast;
int x_warn_integer_division;
int x_warn_intrinsic_shadow;
int x_warn_intrinsics_std;
int x_warn_invalid_memory_model;
int x_warn_invalid_offsetof;
int x_cpp_warn_invalid_pch;
int x_warn_jump_misses_init;
long x_warn_larger_than_size;
int x_warn_line_truncation;
int x_cpp_warn_literal_suffix;
int x_warn_logical_not_paren;
int x_warn_logical_op;
int x_warn_long_long;
int x_warn_lto_type_mismatch;
int x_warn_main;
int x_warn_maybe_uninitialized;
int x_warn_memset_elt_size;
int x_warn_memset_transposed_args;
int x_warn_misleading_indentation;
int x_warn_mismatched_tags;
int x_warn_missing_attributes;
int x_warn_missing_braces;
int x_warn_missing_declarations;
int x_warn_missing_field_initializers;
int x_cpp_warn_missing_include_dirs;
int x_warn_missing_parameter_type;
int x_warn_missing_profile;
int x_warn_missing_prototypes;
int x_cpp_warn_multichar;
int x_warn_multiple_inheritance;
int x_warn_multistatement_macros;
int x_warn_namespaces;
int x_warn_narrowing;
int x_warn_nested_externs;
int x_warn_noexcept;
int x_warn_noexcept_type;
int x_warn_nontemplate_friend;
int x_warn_nonvdtor;
int x_warn_nonnull;
int x_warn_nonnull_compare;
int x_cpp_warn_normalize;
int x_warn_null_dereference;
int x_warn_odr_violations;
int x_warn_old_style_cast;
int x_warn_old_style_declaration;
int x_warn_old_style_definition;
int x_warn_openmp_simd;
int x_warn_overflow;
int x_warn_overlength_strings;
int x_warn_overloaded_virtual;
int x_warn_override_init;
int x_warn_override_init_side_effects;
int x_warn_overwrite_recursive;
int x_warn_packed;
int x_warn_packed_bitfield_compat;
int x_warn_packed_not_aligned;
int x_warn_padded;
int x_warn_parentheses;
int x_pedantic;
int x_warn_pessimizing_move;
int x_warn_placement_new;
int x_warn_pmf2ptr;
int x_warn_pointer_arith;
int x_warn_pointer_compare;
int x_warn_pointer_sign;
int x_warn_pointer_to_int_cast;
int x_warn_pragmas;
int x_warn_prio_ctor_dtor;
int x_warn_property_assign_default;
int x_warn_protocol;
int x_warn_psabi;
int x_warn_real_q_constant;
int x_warn_realloc_lhs;
int x_warn_realloc_lhs_all;
int x_warn_redundant_decls;
int x_warn_redundant_move;
int x_warn_redundant_tags;
int x_warn_register;
int x_warn_reorder;
int x_warn_restrict;
int x_warn_return_local_addr;
int x_warn_return_type;
int x_warn_scalar_storage_order;
int x_warn_selector;
int x_warn_sequence_point;
int x_warn_shadow;
int x_warn_shadow_ivar;
int x_warn_shadow_compatible_local;
int x_warn_shadow_local;
int x_warn_shift_count_negative;
int x_warn_shift_count_overflow;
int x_warn_shift_negative_value;
int x_warn_shift_overflow;
int x_warn_sign_compare;
int x_warn_sign_conversion;
int x_warn_sign_promo;
int x_warn_sized_deallocation;
int x_warn_sizeof_array_argument;
int x_warn_sizeof_pointer_div;
int x_warn_sizeof_pointer_memaccess;
int x_warn_stack_protect;
long x_warn_stack_usage;
int x_warn_strict_aliasing;
int x_warn_strict_null_sentinel;
int x_warn_strict_overflow;
int x_warn_strict_prototypes;
int x_warn_strict_selector_match;
int x_warn_string_compare;
int x_warn_stringop_overflow;
int x_warn_stringop_truncation;
int x_warn_subobject_linkage;
int x_warn_suggest_attribute_cold;
int x_warn_suggest_attribute_const;
int x_warn_suggest_attribute_format;
int x_warn_suggest_attribute_malloc;
int x_warn_suggest_attribute_noreturn;
int x_warn_suggest_attribute_pure;
int x_warn_suggest_final_methods;
int x_warn_suggest_final_types;
int x_warn_override;
int x_warn_surprising;
int x_warn_switch;
int x_warn_switch_bool;
int x_warn_switch_default;
int x_warn_switch_enum;
int x_warn_switch_outside_range;
int x_warn_switch_unreachable;
int x_warn_sync_nand;
int x_warn_synth;
int x_warn_system_headers;
int x_warn_tabs;
int x_warn_target_lifetime;
int x_warn_tautological_compare;
int x_warn_templates;
int x_warn_terminate;
int x_warn_traditional;
int x_warn_traditional_conversion;
int x_warn_trampolines;
int x_cpp_warn_trigraphs;
int x_warn_type_limits;
int x_warn_undeclared_selector;
int x_cpp_warn_undef;
int x_warn_undefined_do_loop;
int x_warn_underflow;
int x_warn_uninitialized;
int x_warn_unknown_pragmas;
int x_warn_unsuffixed_float_constants;
int x_warn_unused;
int x_warn_unused_but_set_parameter;
int x_warn_unused_but_set_variable;
int x_warn_unused_const_variable;
int x_warn_unused_dummy_argument;
int x_warn_unused_function;
int x_warn_unused_label;
int x_warn_unused_local_typedefs;
int x_cpp_warn_unused_macros;
int x_warn_unused_parameter;
int x_warn_unused_result;
int x_warn_unused_value;
int x_warn_unused_variable;
int x_warn_use_without_only;
int x_warn_useless_cast;
int x_warn_varargs;
int x_cpp_warn_variadic_macros;
int x_warn_vector_operation_performance;
int x_warn_virtual_inheritance;
int x_warn_virtual_move_assign;
int x_warn_vla;
long x_warn_vla_limit;
int x_warn_volatile;
int x_warn_volatile_register_var;
int x_warn_write_strings;
int x_warn_zero_as_null_pointer_constant;
int x_warn_zero_length_bounds;
int x_warn_zerotrip;
const char *x_aux_info_file_name;
int x_flag_dump_callgraph;
int x_flag_lto_dump_defined;
int x_flag_lto_dump_demangle;
const char *x_flag_dump_body;
const char *x_flag_dump_level;
const char *x_dump_base_name;
const char *x_dump_base_ext;
const char *x_dump_dir_name;
int x_flag_pic;
int x_flag_pie;
int x_flag_abi_compat_version;
int x_flag_abi_version;
int x_flag_access_control;
const char *x_ada_specs_parent;
int x_flag_aggressive_function_elimination;
int x_flag_aggressive_loop_optimizations;
int x_flag_align_commons;
int x_flag_align_functions;
const char *x_str_align_functions;
int x_flag_align_jumps;
const char *x_str_align_jumps;
int x_flag_align_labels;
const char *x_str_align_labels;
int x_flag_align_loops;
const char *x_str_align_loops;
int x_aligned_new_threshold;
int x_flag_all_intrinsics;
int x_flag_allocation_dce;
int x_flag_allow_argument_mismatch;
int x_flag_allow_invalid_boz;
int x_flag_allow_leading_underscore;
int x_flag_allow_parameterless_variadic_functions;
int x_flag_store_data_races;
int x_flag_analyzer;
int x_flag_analyzer_call_summaries;
const char *x_flag_analyzer_checker;
int x_flag_analyzer_fine_grained;
int x_flag_analyzer_show_duplicate_count;
int x_flag_analyzer_state_merge;
int x_flag_analyzer_state_purge;
int x_flag_analyzer_transitivity;
int x_flag_analyzer_verbose_edges;
int x_flag_analyzer_verbose_state_changes;
int x_analyzer_verbosity;
void *x_common_deferred_options;
int x_flag_no_asm;
int x_flag_assert;
int x_flag_associative_math;
int x_flag_assume_phsa;
int x_flag_asynchronous_unwind_tables;
int x_flag_auto_inc_dec;
int x_flag_auto_profile;
const char *x_auto_profile_file;
int x_flag_automatic;
int x_flag_backslash;
int x_flag_backtrace;
int x_flag_blas_matmul_limit;
int x_flag_bounds_check;
int x_flag_branch_on_count_reg;
int x_flag_branch_probabilities;
int x_flag_building_libgcc;
int x_flag_building_libphobos_tests;
int x_flag_no_builtin;
int x_flag_c_prototypes;
int x_flag_c_prototypes_external;
int x_flag_caller_saves;
int x_flag_callgraph_info;
enum cf_protection_level x_flag_cf_protection;
int x_flag_char8_t;
int x_flag_check_new;
int x_flag_checking;
enum gfc_fcoarray x_flag_coarray;
int x_flag_code_hoisting;
int x_flag_combine_stack_adjustments;
int x_flag_no_common;
int x_flag_compare_debug;
const char *x_flag_compare_debug_opt;
int x_flag_compare_elim_after_reload;
int x_flag_concepts;
int x_concepts_diagnostics_max_depth;
int x_flag_concepts_ts;
int x_flag_conserve_stack;
int x_constexpr_cache_depth;
int x_max_constexpr_depth;
int x_constexpr_loop_limit;
long x_constexpr_ops_limit;
enum gfc_convert x_flag_convert;
int x_flag_coroutines;
int x_flag_cprop_registers;
int x_flag_cray_pointer;
int x_flag_crossjumping;
int x_flag_cse_follow_jumps;
int x_flag_cx_fortran_rules;
int x_flag_cx_limited_range;
int x_flag_data_sections;
int x_flag_dce;
int x_flag_debug_types_section;
int x_flag_dec;
int x_flag_dec_blank_format_item;
int x_flag_dec_char_conversions;
int x_flag_dec_format_defaults;
int x_flag_dec_include;
int x_flag_dec_intrinsic_ints;
int x_flag_dec_math;
int x_flag_dec_static;
int x_flag_dec_structure;
int x_flag_declone_ctor_dtor;
int x_flag_default_double;
int x_flag_default_integer;
int x_flag_default_real_10;
int x_flag_default_real_16;
int x_flag_default_real_8;
int x_flag_defer_pop;
int x_flag_delayed_branch;
int x_flag_delete_dead_exceptions;
int x_flag_delete_null_pointer_checks;
int x_flag_devirtualize;
int x_flag_ltrans_devirtualize;
int x_flag_devirtualize_speculatively;
int x_flag_diagnostics_show_color;
int x_flag_diagnostics_generate_patch;
int x_diagnostics_minimum_margin_width;
int x_flag_diagnostics_parseable_fixits;
int x_flag_diagnostics_path_format;
int x_flag_diagnostics_show_caret;
int x_flag_diagnostics_show_cwe;
int x_flag_diagnostics_show_labels;
int x_flag_diagnostics_show_line_numbers;
int x_flag_diagnostics_show_option;
int x_flag_diagnostics_show_path_depths;
int x_flag_diagnostics_show_template_tree;
int x_flag_diagnostics_show_urls;
int x_flag_dollar_ok;
int x_flag_dse;
int x_flag_dump_ada_spec;
int x_flag_dump_ada_spec_slim;
int x_flag_dump_analyzer;
int x_flag_dump_analyzer_callgraph;
int x_flag_dump_analyzer_exploded_graph;
int x_flag_dump_analyzer_exploded_nodes;
int x_flag_dump_analyzer_exploded_nodes_2;
int x_flag_dump_analyzer_exploded_nodes_3;
int x_flag_dump_analyzer_state_purge;
int x_flag_dump_analyzer_stderr;
int x_flag_dump_analyzer_supergraph;
const char *x_flag_dump_final_insns;
int x_flag_dump_fortran_global;
int x_flag_dump_fortran_optimized;
int x_flag_dump_fortran_original;
const char *x_flag_dump_go_spec;
int x_flag_dump_locations;
int x_flag_dump_noaddr;
int x_flag_dump_passes;
int x_flag_dump_scos;
int x_flag_dump_unnumbered;
int x_flag_dump_unnumbered_links;
int x_flag_dwarf2_cfi_asm;
int x_flag_early_inlining;
int x_flag_elide_constructors;
int x_flag_elide_type;
int x_flag_debug_only_used_symbols;
int x_flag_eliminate_unused_debug_types;
int x_flag_emit_class_debug_always;
int x_flag_enforce_eh_specs;
int x_flag_exceptions;
enum excess_precision x_flag_excess_precision;
int x_flag_expensive_optimizations;
int x_flag_ext_numeric_literals;
int x_flag_extern_tls_init;
int x_flag_external_blas;
int x_flag_f2c;
int x_flag_fat_lto_objects;
int x_flag_finite_loops;
int x_flag_finite_math_only;
int x_flag_fixed_line_length;
int x_flag_float_store;
int x_flag_forward_propagate;
enum fp_contract_mode x_flag_fp_contract_mode;
int x_flag_fp_int_builtin_inexact;
int x_flag_free_line_length;
int x_flag_frontend_loop_interchange;
int x_flag_frontend_optimize;
int x_flag_no_function_cse;
int x_flag_function_sections;
int x_flag_gcse;
int x_flag_gcse_after_reload;
int x_flag_gcse_las;
int x_flag_gcse_lm;
int x_flag_gcse_sm;
int x_flag_gimple;
int x_flag_no_gnu_keywords;
int x_flag_next_runtime;
int x_flag_tm;
int x_flag_gnu_unique;
int x_flag_gnu89_inline;
int x_go_check_divide_overflow;
int x_go_check_divide_zero;
int x_go_compiling_runtime;
int x_go_debug_escape_level;
const char *x_go_debug_escape_hash;
int x_go_debug_optimization;
int x_flag_graphite;
int x_flag_graphite_identity;
int x_flag_guess_branch_prob;
int x_flag_hoist_adjacent_loads;
int x_flag_no_ident;
int x_flag_if_conversion;
int x_flag_if_conversion2;
int x_flag_implement_inlines;
int x_flag_implicit_inline_templates;
int x_flag_implicit_none;
int x_flag_implicit_templates;
int x_flag_indirect_inlining;
int x_flag_inhibit_size_directive;
int x_flag_init_derived;
enum gfc_init_local_real x_flag_init_real;
int x_flag_no_inline;
int x_flag_inline_arg_packing;
int x_flag_inline_atomics;
int x_flag_inline_functions;
int x_flag_inline_functions_called_once;
int x_flag_inline_matmul_limit;
int x_flag_inline_small_functions;
int x_flag_instrument_function_entry_exit;
int x_flag_integer4_kind;
int x_flag_invariants;
int x_flag_ipa_bit_cp;
int x_flag_ipa_cp;
int x_flag_ipa_cp_clone;
int x_flag_ipa_icf;
int x_flag_ipa_icf_functions;
int x_flag_ipa_icf_variables;
int x_flag_ipa_profile;
int x_flag_ipa_pta;
int x_flag_ipa_pure_const;
int x_flag_ipa_ra;
int x_flag_ipa_reference;
int x_flag_ipa_reference_addressable;
int x_flag_ipa_sra;
int x_flag_ipa_stack_alignment;
int x_flag_ipa_vrp;
enum ira_algorithm x_flag_ira_algorithm;
int x_flag_ira_hoist_pressure;
int x_flag_ira_loop_pressure;
enum ira_region x_flag_ira_region;
int x_flag_ira_share_save_slots;
int x_flag_ira_share_spill_slots;
int x_flag_ira_verbose;
int x_flag_isolate_erroneous_paths_attribute;
int x_flag_isolate_erroneous_paths_dereference;
enum ivar_visibility x_default_ivar_visibility;
int x_flag_ivopts;
int x_flag_jump_tables;
int x_flag_keep_gc_roots_live;
int x_flag_keep_inline_dllexport;
int x_flag_keep_inline_functions;
int x_flag_keep_static_consts;
int x_flag_keep_static_functions;
int x_flag_large_source_files;
int x_flag_lax_vector_conversions;
int x_flag_leading_underscore;
int x_flag_lifetime_dse;
int x_flag_limit_function_alignment;
enum lto_linker_output x_flag_lto_linker_output;
enum live_patching_level x_flag_live_patching;
int x_flag_live_range_shrinkage;
int x_flag_local_ivars;
int x_flag_loop_interchange;
int x_flag_loop_nest_optimize;
int x_flag_loop_parallelize_all;
int x_flag_unroll_jam;
int x_flag_lra_remat;
int x_flag_lto_compression_level;
enum lto_partition_model x_flag_lto_partition;
int x_flag_lto_report;
int x_flag_lto_report_wpa;
const char *x_flag_lto;
int x_flag_ltrans;
const char *x_ltrans_output_list;
int x_flag_errno_math;
int x_flag_max_array_constructor;
int x_flag_max_errors;
int x_flag_max_stack_var_size;
int x_flag_max_subrecord_length;
int x_mem_report;
int x_mem_report_wpa;
int x_flag_merge_constants;
int x_flag_merge_debug_strings;
int x_flag_module_private;
int x_flag_moduleinfo;
int x_flag_modulo_sched;
int x_flag_modulo_sched_allow_regmoves;
int x_flag_move_loop_invariants;
int x_flag_ms_extensions;
int x_flag_new_inheriting_ctors;
int x_flag_new_ttp;
int x_flag_nil_receivers;
int x_flag_non_call_exceptions;
int x_flag_no_nonansi_builtin;
int x_flag_nothrow_opt;
int x_flag_objc_abi;
int x_flag_objc_call_cxx_cdtors;
int x_flag_objc_direct_dispatch;
int x_flag_objc_exceptions;
int x_flag_objc_gc;
int x_flag_objc_nilcheck;
int x_flag_objc_sjlj_exceptions;
int x_flag_objc1_only;
enum offload_abi x_flag_offload_abi;
int x_flag_omit_frame_pointer;
int x_flag_openacc;
const char *x_flag_openacc_dims;
int x_flag_openmp;
int x_flag_openmp_simd;
int x_flag_opt_info;
int x_flag_optimize_sibling_calls;
int x_flag_optimize_strlen;
int x_flag_pack_derived;
int x_flag_pack_struct;
int x_flag_pad_source;
int x_flag_partial_inlining;
int x_flag_pcc_struct_return;
int x_flag_peel_loops;
int x_flag_no_peephole;
int x_flag_peephole2;
int x_flag_permissive;
enum permitted_flt_eval_methods x_flag_permitted_flt_eval_methods;
int x_flag_plan9_extensions;
int x_flag_plt;
int x_post_ipa_mem_report;
int x_flag_postconditions;
const char *x_flag_pre_include;
int x_pre_ipa_mem_report;
int x_flag_preconditions;
int x_flag_predictive_commoning;
int x_flag_prefetch_loop_arrays;
int x_flag_pretty_templates;
int x_flag_printf_return_value;
int x_profile_flag;
int x_profile_abs_path_flag;
int x_profile_arc_flag;
int x_flag_profile_correction;
const char *x_profile_data_prefix;
const char *x_flag_profile_exclude_files;
const char *x_flag_profile_filter_files;
const char *x_profile_note_location;
int x_flag_profile_partial_training;
const char *x_profile_prefix_path;
int x_flag_profile_reorder_functions;
int x_profile_report;
enum profile_reproducibility x_flag_profile_reproducible;
enum profile_update x_flag_profile_update;
int x_flag_profile_use;
int x_flag_profile_values;
int x_flag_protect_parens;
int x_flag_range_check;
int x_flag_real4_kind;
int x_flag_real8_kind;
int x_flag_realloc_lhs;
int x_flag_reciprocal_math;
int x_flag_record_gcc_switches;
int x_flag_record_marker;
int x_flag_recursive;
int x_flag_ree;
int x_flag_rename_registers;
int x_flag_reorder_blocks;
enum reorder_blocks_algorithm x_flag_reorder_blocks_algorithm;
int x_flag_reorder_blocks_and_partition;
int x_flag_reorder_functions;
int x_flag_repack_arrays;
int x_flag_replace_objc_classes;
int x_flag_report_bug;
int x_go_require_return_statement;
int x_flag_rerun_cse_after_loop;
int x_flag_resched_modulo_sched;
int x_flag_rounding_math;
int x_flag_rtti;
int x_flag_sanitize_address_use_after_scope;
int x_flag_sanitize_undefined_trap_on_error;
int x_flag_save_optimization_record;
int x_flag_sched_critical_path_heuristic;
int x_flag_sched_dep_count_heuristic;
int x_flag_sched_group_heuristic;
int x_flag_schedule_interblock;
int x_flag_sched_last_insn_heuristic;
int x_flag_sched_pressure;
int x_flag_sched_rank_heuristic;
int x_flag_schedule_speculative;
int x_flag_sched_spec_insn_heuristic;
int x_flag_schedule_speculative_load;
int x_flag_schedule_speculative_load_dangerous;
int x_flag_sched_stalled_insns;
int x_flag_sched_stalled_insns_dep;
int x_sched_verbose_param;
int x_flag_sched2_use_superblocks;
int x_flag_schedule_fusion;
int x_flag_schedule_insns;
int x_flag_schedule_insns_after_reload;
int x_flag_second_underscore;
int x_flag_section_anchors;
int x_flag_sel_sched_pipelining;
int x_flag_sel_sched_pipelining_outer_loops;
int x_flag_sel_sched_reschedule_pipelined;
int x_flag_selective_scheduling;
int x_flag_selective_scheduling2;
const char *x_flag_self_test;
int x_flag_semantic_interposition;
int x_flag_short_enums;
int x_flag_short_wchar;
int x_flag_show_column;
int x_flag_shrink_wrap;
int x_flag_shrink_wrap_separate;
int x_flag_sign_zero;
int x_flag_signaling_nans;
int x_flag_signed_bitfields;
int x_flag_signed_char;
int x_flag_signed_zeros;
enum vect_cost_model x_flag_simd_cost_model;
int x_flag_single_precision_constant;
int x_flag_sized_deallocation;
int x_flag_split_ivs_in_unroller;
int x_flag_split_loops;
int x_flag_split_paths;
int x_flag_split_stack;
int x_flag_split_wide_types;
int x_flag_split_wide_types_early;
int x_flag_ssa_backprop;
int x_flag_ssa_phiopt;
enum scalar_storage_order_kind x_default_sso;
int x_flag_stack_arrays;
int x_flag_stack_clash_protection;
int x_flag_stack_protect;
enum stack_reuse_level x_flag_stack_reuse;
int x_flag_stack_usage;
int x_flag_detailed_statistics;
int x_flag_stdarg_opt;
int x_flag_store_merging;
int x_flag_strict_aliasing;
int x_flag_strict_enums;
int x_flag_strict_volatile_bitfields;
int x_flag_strong_eval_order;
int x_flag_switch_errors;
int x_flag_sync_libcalls;
int x_flag_syntax_only;
int x_flag_tail_call_workaround;
int x_template_backtrace_limit;
int x_flag_test_coverage;
int x_flag_test_forall_temp;
int x_flag_thread_jumps;
int x_flag_threadsafe_statics;
int x_time_report;
int x_time_report_details;
enum tls_model x_flag_tls_default;
int x_flag_toplevel_reorder;
int x_flag_tracer;
int x_flag_trampolines;
int x_flag_trapping_math;
int x_flag_trapv;
int x_flag_tree_bit_ccp;
int x_flag_tree_builtin_call_dce;
int x_flag_tree_ccp;
int x_flag_tree_ch;
int x_flag_tree_coalesce_vars;
int x_flag_tree_copy_prop;
int x_flag_tree_cselim;
int x_flag_tree_dce;
int x_flag_tree_dom;
int x_flag_tree_dse;
int x_flag_tree_forwprop;
int x_flag_tree_fre;
int x_flag_tree_loop_distribute_patterns;
int x_flag_tree_loop_distribution;
int x_flag_tree_loop_if_convert;
int x_flag_tree_loop_im;
int x_flag_tree_loop_ivcanon;
int x_flag_tree_loop_optimize;
int x_flag_tree_loop_vectorize;
int x_flag_tree_live_range_split;
int x_flag_tree_parallelize_loops;
int x_flag_tree_partial_pre;
int x_flag_tree_phiprop;
int x_flag_tree_pre;
int x_flag_tree_pta;
int x_flag_tree_reassoc;
int x_flag_tree_scev_cprop;
int x_flag_tree_sink;
int x_flag_tree_slp_vectorize;
int x_flag_tree_slsr;
int x_flag_tree_sra;
int x_flag_tree_switch_conversion;
int x_flag_tree_tail_merge;
int x_flag_tree_ter;
int x_flag_tree_vrp;
int x_flag_unconstrained_commons;
int x_flag_underscoring;
int x_flag_unit_at_a_time;
int x_flag_unroll_all_loops;
int x_flag_cunroll_grow_size;
int x_flag_unroll_loops;
int x_flag_unsafe_math_optimizations;
int x_flag_unswitch_loops;
int x_flag_unwind_tables;
int x_flag_use_cxa_atexit;
int x_flag_use_cxa_get_exception_ptr;
int x_flag_use_linker_plugin;
int x_flag_var_tracking;
int x_flag_var_tracking_assignments;
int x_flag_var_tracking_assignments_toggle;
int x_flag_var_tracking_uninit;
int x_flag_variable_expansion_in_unroller;
enum vect_cost_model x_flag_vect_cost_model;
int x_flag_verbose_asm;
int x_flag_version_loops_for_strides;
int x_flag_visibility_ms_compat;
enum symbol_visibility x_default_visibility;
int x_flag_value_profile_transformations;
enum vtv_priority x_flag_vtable_verify;
int x_flag_vtv_counts;
int x_flag_vtv_debug;
int x_flag_weak;
int x_flag_web;
int x_flag_whole_program;
int x_flag_working_directory;
const char *x_flag_wpa;
int x_flag_wrapv;
int x_flag_wrapv_pointer;
int x_flag_zero_initialized_in_bss;
int x_flag_zero_link;
int x_dwarf2out_as_loc_support;
int x_dwarf2out_as_locview_support;
int x_debug_column_info;
int x_flag_describe_dies;
int x_dwarf_version;
int x_flag_gen_declaration;
int x_debug_generate_pub_sections;
int x_flag_lto_gimple_stats;
int x_debug_inline_points;
int x_debug_internal_reset_location_views;
int x_dwarf_record_gcc_switches;
int x_dwarf_split_debug_info;
int x_debug_nonbind_markers_p;
int x_dwarf_strict;
int x_flag_gtoggle;
int x_debug_variable_location_views;
int x_flag_lto_dump_tool_help;
const char *x_imultiarch;
const char *x_plugindir_string;
int x_flag_lto_dump_list;
enum calling_abi x_ix86_abi;
enum pmode x_ix86_pmode;
enum ix86_align_data x_ix86_align_data_type;
int x_flag_android;
const char *x_ix86_arch_string;
enum asm_dialect x_ix86_asm_dialect;
int x_linux_libc;
int x_ix86_branch_cost;
int x_flag_cet_switch;
enum cmodel x_ix86_cmodel;
int x_flag_dispatch_scheduler;
int x_ix86_dump_tunes;
int x_flag_fentry;
const char *x_fentry_name;
const char *x_fentry_section;
int x_ix86_force_drap;
int x_flag_force_indirect_call;
enum fpmath_unit x_ix86_fpmath;
enum indirect_branch x_ix86_function_return;
int x_ix86_incoming_stack_boundary_arg;
int x_ix86_indirect_branch_register;
enum indirect_branch x_ix86_indirect_branch;
enum instrument_return x_ix86_instrument_return;
int x_ix86_section_threshold;
int x_flag_manual_endbr;
const char *x_ix86_tune_memcpy_strategy;
const char *x_ix86_tune_memset_strategy;
int x_ix86_tune_no_default;
int x_flag_nop_mcount;
enum prefer_vector_width x_prefer_vector_width_type;
int x_ix86_preferred_stack_boundary_arg;
const char *x_ix86_recip_name;
int x_flag_record_mcount;
int x_ix86_flag_record_return;
int x_ix86_regparm;
int x_flag_skip_rax_setup;
int x_ix86_sse2avx;
const char *x_ix86_stack_protector_guard_offset_str;
const char *x_ix86_stack_protector_guard_reg_str;
const char *x_ix86_stack_protector_guard_symbol_str;
enum stack_protector_guard x_ix86_stack_protector_guard;
int x_ix86_force_align_arg_pointer;
enum stringop_alg x_ix86_stringop_alg;
enum tls_dialect x_ix86_tls_dialect;
const char *x_ix86_tune_ctrl_string;
const char *x_ix86_tune_string;
enum ix86_veclibabi x_ix86_veclibabi_type;
int x_flag_lto_name_sort;
const char *x_asm_file_name;
int x_flag_lto_dump_objects;
int x_pass_exit_codes;
int x_flag_pedantic_errors;
int x_use_pipes;
const char *x_print_file_name;
int x_print_multi_directory;
int x_print_multi_lib;
int x_print_multi_os_directory;
int x_print_multiarch;
const char *x_print_prog_name;
int x_print_search_dirs;
int x_print_sysroot;
int x_print_sysroot_headers_suffix;
int x_flag_lto_print_value;
int x_quiet_flag;
int x_flag_lto_reverse_sort;
int x_flag_lto_size_sort;
const char *x_flag_lto_dump_symbol;
int x_report_times;
int x_flag_lto_tree_stats;
int x_flag_lto_dump_type_stats;
int x_flag_undef;
int x_verbose_flag;
int x_version_flag;
int x_inhibit_warnings;
const char *x_wrapper_string;
int x_VAR_malign_functions_;
int x_VAR_malign_jumps_;
int x_VAR_malign_loops_;
int x_VAR_mmitigate_rop;
int x_VAR_mmpx;
int x_VAR_mpc32;
int x_VAR_mpc64;
int x_VAR_mpc80;
int x_VAR_mpcommit;
bool frontend_set_flag_associative_math;
bool frontend_set_flag_cx_limited_range;
bool frontend_set_flag_excess_precision;
bool frontend_set_flag_finite_math_only;
bool frontend_set_flag_errno_math;
bool frontend_set_flag_reciprocal_math;
bool frontend_set_flag_rounding_math;
bool frontend_set_flag_signaling_nans;
bool frontend_set_flag_signed_zeros;
bool frontend_set_flag_trapping_math;
bool frontend_set_flag_unsafe_math_optimizations;
};
extern struct gcc_options global_options;
extern const struct gcc_options global_options_init;
extern struct gcc_options global_options_set;
struct cl_optimization
{
const char *x_str_align_functions;
const char *x_str_align_jumps;
const char *x_str_align_labels;
const char *x_str_align_loops;
int x_param_align_loop_iterations;
int x_param_align_threshold;
int x_param_asan_protect_allocas;
int x_param_asan_instrument_reads;
int x_param_asan_instrument_writes;
int x_param_asan_instrumentation_with_call_threshold;
int x_param_asan_memintrin;
int x_param_asan_stack;
int x_param_asan_use_after_return;
int x_param_avg_loop_niter;
int x_param_avoid_fma_max_bits;
int x_param_builtin_expect_probability;
int x_param_builtin_string_cmp_inline_length;
int x_param_case_values_threshold;
int x_param_comdat_sharing_probability;
int x_param_dse_max_alias_queries_per_store;
int x_param_dse_max_object_size;
int x_param_early_inlining_insns;
int x_param_fsm_maximum_phi_arguments;
int x_param_fsm_scale_path_blocks;
int x_param_fsm_scale_path_stmts;
int x_param_gcse_after_reload_critical_fraction;
int x_param_gcse_after_reload_partial_fraction;
int x_param_gcse_cost_distance_ratio;
int x_param_gcse_unrestricted_cost;
int x_param_graphite_max_arrays_per_scop;
int x_param_graphite_max_nb_scop_params;
int x_param_inline_heuristics_hint_percent;
int x_param_inline_min_speedup;
int x_param_inline_unit_growth;
int x_param_ipa_cp_eval_threshold;
int x_param_ipa_cp_loop_hint_bonus;
int x_param_ipa_cp_max_recursive_depth;
int x_param_ipa_cp_min_recursive_probability;
int x_param_ipa_cp_recursion_penalty;
int x_param_ipa_cp_single_call_penalty;
int x_param_ipa_cp_unit_growth;
int x_param_ipa_cp_value_list_size;
int x_param_ipa_max_aa_steps;
int x_param_ipa_max_agg_items;
int x_param_ipa_max_param_expr_ops;
int x_param_ipa_max_switch_predicate_bounds;
int x_param_ipa_sra_max_replacements;
int x_param_ipa_sra_ptr_growth_factor;
int x_param_ira_loop_reserved_regs;
int x_param_ira_max_conflict_table_size;
int x_param_ira_max_loops_num;
int x_param_iv_always_prune_cand_set_bound;
int x_param_iv_consider_all_candidates_bound;
int x_param_iv_max_considered_uses;
int x_param_jump_table_max_growth_ratio_for_size;
int x_param_jump_table_max_growth_ratio_for_speed;
int x_param_l1_cache_line_size;
int x_param_l1_cache_size;
int x_param_l2_cache_size;
int x_param_large_function_growth;
int x_param_large_function_insns;
int x_param_stack_frame_growth;
int x_param_large_stack_frame;
int x_param_large_unit_insns;
int x_param_lim_expensive;
int x_param_loop_block_tile_size;
int x_param_loop_interchange_max_num_stmts;
int x_param_loop_interchange_stride_ratio;
int x_param_loop_invariant_max_bbs_in_loop;
int x_param_loop_max_datarefs_for_datadeps;
int x_param_loop_versioning_max_inner_insns;
int x_param_loop_versioning_max_outer_insns;
int x_param_lra_inheritance_ebb_probability_cutoff;
int x_param_lra_max_considered_reload_pseudos;
int x_param_max_average_unrolled_insns;
int x_param_max_combine_insns;
int x_param_max_unroll_iterations;
int x_param_max_completely_peel_times;
int x_param_max_completely_peeled_insns;
int x_param_max_crossjump_edges;
int x_param_max_cse_insns;
int x_param_max_cse_path_length;
int x_param_max_cselib_memory_locations;
int x_param_max_debug_marker_count;
int x_param_max_delay_slot_insn_search;
int x_param_max_delay_slot_live_search;
int x_param_max_dse_active_local_stores;
int x_param_early_inliner_max_iterations;
int x_param_max_find_base_term_values;
int x_param_max_fsm_thread_length;
int x_param_max_fsm_thread_path_insns;
int x_param_max_fsm_thread_paths;
int x_param_max_gcse_insertion_ratio;
int x_param_max_gcse_memory;
int x_param_max_goto_duplication_insns;
int x_param_max_grow_copy_bb_insns;
int x_param_max_hoist_depth;
int x_param_max_inline_insns_auto;
int x_param_max_inline_insns_recursive_auto;
int x_param_max_inline_insns_recursive;
int x_param_max_inline_insns_single;
int x_param_max_inline_insns_size;
int x_param_max_inline_insns_small;
int x_param_max_inline_recursive_depth_auto;
int x_param_max_inline_recursive_depth;
int x_param_max_isl_operations;
int x_param_max_iterations_computation_cost;
int x_param_max_iterations_to_track;
int x_param_max_jump_thread_duplication_stmts;
int x_param_max_last_value_rtl;
int x_param_max_loop_header_insns;
int x_param_max_modulo_backtrack_attempts;
int x_param_max_partial_antic_length;
int x_param_max_peel_branches;
int x_param_max_peel_times;
int x_param_max_peeled_insns;
int x_param_max_pending_list_length;
int x_param_max_pipeline_region_blocks;
int x_param_max_pipeline_region_insns;
int x_param_max_pow_sqrt_depth;
int x_param_max_predicted_iterations;
int x_param_max_reload_search_insns;
int x_param_max_rtl_if_conversion_insns;
int x_param_max_rtl_if_conversion_predictable_cost;
int x_param_max_rtl_if_conversion_unpredictable_cost;
int x_param_max_sched_extend_regions_iters;
int x_param_max_sched_insn_conflict_delay;
int x_param_max_sched_ready_insns;
int x_param_max_sched_region_blocks;
int x_param_max_sched_region_insns;
int x_param_max_slsr_candidate_scan;
int x_param_max_speculative_devirt_maydefs;
int x_param_max_stores_to_merge;
int x_param_max_stores_to_sink;
int x_param_max_tail_merge_comparisons;
int x_param_max_tail_merge_iterations;
int x_param_max_tracked_strlens;
int x_param_max_tree_if_conversion_phi_args;
int x_param_max_unroll_times;
int x_param_max_unrolled_insns;
int x_param_max_unswitch_insns;
int x_param_max_unswitch_level;
int x_param_max_variable_expansions;
int x_param_max_vartrack_expr_depth;
int x_param_max_vartrack_reverse_op_size;
int x_param_max_vartrack_size;
int x_param_max_vrp_switch_assertions;
int x_param_min_crossjump_insns;
int x_param_min_inline_recursive_probability;
int x_param_min_insn_to_prefetch_ratio;
int x_param_min_loop_cond_split_prob;
int x_param_min_size_for_stack_sharing;
int x_param_min_spec_prob;
int x_param_min_vect_loop_bound;
int x_param_parloops_chunk_size;
int x_param_parloops_min_per_thread;
int x_param_parloops_schedule;
int x_param_partial_inlining_entry_probability;
int x_param_predictable_branch_outcome;
int x_param_prefetch_dynamic_strides;
int x_param_prefetch_latency;
int x_param_prefetch_min_insn_to_mem_ratio;
int x_param_prefetch_minimum_stride;
int x_param_rpo_vn_max_loop_depth;
int x_param_sccvn_max_alias_queries_per_access;
int x_param_scev_max_expr_complexity;
int x_param_scev_max_expr_size;
int x_param_sched_autopref_queue_depth;
int x_param_sched_mem_true_dep_cost;
int x_param_sched_pressure_algorithm;
int x_param_sched_spec_prob_cutoff;
int x_param_sched_state_edge_prob_cutoff;
int x_param_selsched_insns_to_rename;
int x_param_selsched_max_lookahead;
int x_param_selsched_max_sched_times;
int x_param_simultaneous_prefetches;
int x_param_sink_frequency_threshold;
int x_param_slp_max_insns_in_bb;
int x_param_sms_dfa_history;
int x_param_sms_loop_average_count_threshold;
int x_param_sms_max_ii_factor;
int x_param_sms_min_sc;
int x_param_sra_max_propagations;
int x_param_sra_max_scalarization_size_size;
int x_param_sra_max_scalarization_size_speed;
int x_param_ssa_name_def_chain_limit;
int x_param_ssp_buffer_size;
int x_param_stack_clash_protection_guard_size;
int x_param_stack_clash_protection_probe_interval;
int x_param_store_merging_allow_unaligned;
int x_param_store_merging_max_size;
int x_param_switch_conversion_branch_ratio;
int x_param_tm_max_aggregate_size;
int x_param_tracer_dynamic_coverage_feedback;
int x_param_tracer_dynamic_coverage;
int x_param_tracer_max_code_growth;
int x_param_tracer_min_branch_probability_feedback;
int x_param_tracer_min_branch_probability;
int x_param_tracer_min_branch_ratio;
int x_param_tree_reassoc_width;
int x_param_uninit_control_dep_attempts;
int x_param_uninlined_function_insns;
int x_param_uninlined_function_time;
int x_param_uninlined_function_thunk_insns;
int x_param_uninlined_function_thunk_time;
int x_param_unlikely_bb_count_fraction;
int x_param_unroll_jam_max_unroll;
int x_param_unroll_jam_min_percent;
int x_param_use_after_scope_direct_emission_threshold;
int x_param_vect_epilogues_nomask;
int x_param_vect_max_peeling_for_alignment;
int x_param_vect_max_version_for_alias_checks;
int x_param_vect_max_version_for_alignment_checks;
int x_param_vect_partial_vector_usage;
int x_flag_sched_stalled_insns;
int x_flag_sched_stalled_insns_dep;
int x_flag_tree_parallelize_loops;
enum excess_precision x_flag_excess_precision;
enum fp_contract_mode x_flag_fp_contract_mode;
enum ira_algorithm x_flag_ira_algorithm;
enum ira_region x_flag_ira_region;
enum live_patching_level x_flag_live_patching;
enum reorder_blocks_algorithm x_flag_reorder_blocks_algorithm;
enum vect_cost_model x_flag_simd_cost_model;
enum stack_reuse_level x_flag_stack_reuse;
enum vect_cost_model x_flag_vect_cost_model;
unsigned char x_optimize;
unsigned char x_optimize_size;
unsigned char x_optimize_debug;
unsigned char x_optimize_fast;
signed char x_warn_inline;
signed char x_flag_aggressive_loop_optimizations;
signed char x_flag_align_functions;
signed char x_flag_align_jumps;
signed char x_flag_align_labels;
signed char x_flag_align_loops;
signed char x_flag_allocation_dce;
signed char x_flag_store_data_races;
signed char x_flag_associative_math;
signed char x_flag_assume_phsa;
signed char x_flag_asynchronous_unwind_tables;
signed char x_flag_auto_inc_dec;
signed char x_flag_branch_on_count_reg;
signed char x_flag_branch_probabilities;
signed char x_flag_caller_saves;
signed char x_flag_code_hoisting;
signed char x_flag_combine_stack_adjustments;
signed char x_flag_compare_elim_after_reload;
signed char x_flag_conserve_stack;
signed char x_flag_cprop_registers;
signed char x_flag_crossjumping;
signed char x_flag_cse_follow_jumps;
signed char x_flag_cx_fortran_rules;
signed char x_flag_cx_limited_range;
signed char x_flag_dce;
signed char x_flag_defer_pop;
signed char x_flag_delayed_branch;
signed char x_flag_delete_dead_exceptions;
signed char x_flag_delete_null_pointer_checks;
signed char x_flag_devirtualize;
signed char x_flag_devirtualize_speculatively;
signed char x_flag_dse;
signed char x_flag_early_inlining;
signed char x_flag_exceptions;
signed char x_flag_expensive_optimizations;
signed char x_flag_finite_loops;
signed char x_flag_finite_math_only;
signed char x_flag_float_store;
signed char x_flag_forward_propagate;
signed char x_flag_fp_int_builtin_inexact;
signed char x_flag_no_function_cse;
signed char x_flag_gcse;
signed char x_flag_gcse_after_reload;
signed char x_flag_gcse_las;
signed char x_flag_gcse_lm;
signed char x_flag_gcse_sm;
signed char x_flag_graphite;
signed char x_flag_graphite_identity;
signed char x_flag_guess_branch_prob;
signed char x_flag_hoist_adjacent_loads;
signed char x_flag_if_conversion;
signed char x_flag_if_conversion2;
signed char x_flag_indirect_inlining;
signed char x_flag_no_inline;
signed char x_flag_inline_atomics;
signed char x_flag_inline_functions;
signed char x_flag_inline_functions_called_once;
signed char x_flag_inline_small_functions;
signed char x_flag_ipa_bit_cp;
signed char x_flag_ipa_cp;
signed char x_flag_ipa_cp_clone;
signed char x_flag_ipa_icf;
signed char x_flag_ipa_icf_functions;
signed char x_flag_ipa_icf_variables;
signed char x_flag_ipa_profile;
signed char x_flag_ipa_pta;
signed char x_flag_ipa_pure_const;
signed char x_flag_ipa_ra;
signed char x_flag_ipa_reference;
signed char x_flag_ipa_reference_addressable;
signed char x_flag_ipa_sra;
signed char x_flag_ipa_stack_alignment;
signed char x_flag_ipa_vrp;
signed char x_flag_ira_hoist_pressure;
signed char x_flag_ira_loop_pressure;
signed char x_flag_ira_share_save_slots;
signed char x_flag_ira_share_spill_slots;
signed char x_flag_isolate_erroneous_paths_attribute;
signed char x_flag_isolate_erroneous_paths_dereference;
signed char x_flag_ivopts;
signed char x_flag_jump_tables;
signed char x_flag_keep_gc_roots_live;
signed char x_flag_lifetime_dse;
signed char x_flag_limit_function_alignment;
signed char x_flag_live_range_shrinkage;
signed char x_flag_loop_interchange;
signed char x_flag_loop_nest_optimize;
signed char x_flag_loop_parallelize_all;
signed char x_flag_unroll_jam;
signed char x_flag_lra_remat;
signed char x_flag_errno_math;
signed char x_flag_modulo_sched;
signed char x_flag_modulo_sched_allow_regmoves;
signed char x_flag_move_loop_invariants;
signed char x_flag_non_call_exceptions;
signed char x_flag_nothrow_opt;
signed char x_flag_omit_frame_pointer;
signed char x_flag_opt_info;
signed char x_flag_optimize_sibling_calls;
signed char x_flag_optimize_strlen;
signed char x_flag_pack_struct;
signed char x_flag_partial_inlining;
signed char x_flag_peel_loops;
signed char x_flag_no_peephole;
signed char x_flag_peephole2;
signed char x_flag_plt;
signed char x_flag_predictive_commoning;
signed char x_flag_prefetch_loop_arrays;
signed char x_flag_printf_return_value;
signed char x_flag_profile_partial_training;
signed char x_flag_profile_reorder_functions;
signed char x_flag_reciprocal_math;
signed char x_flag_ree;
signed char x_flag_pcc_struct_return;
signed char x_flag_rename_registers;
signed char x_flag_reorder_blocks;
signed char x_flag_reorder_blocks_and_partition;
signed char x_flag_reorder_functions;
signed char x_flag_rerun_cse_after_loop;
signed char x_flag_resched_modulo_sched;
signed char x_flag_rounding_math;
signed char x_flag_rtti;
signed char x_flag_save_optimization_record;
signed char x_flag_sched_critical_path_heuristic;
signed char x_flag_sched_dep_count_heuristic;
signed char x_flag_sched_group_heuristic;
signed char x_flag_schedule_interblock;
signed char x_flag_sched_last_insn_heuristic;
signed char x_flag_sched_pressure;
signed char x_flag_sched_rank_heuristic;
signed char x_flag_schedule_speculative;
signed char x_flag_sched_spec_insn_heuristic;
signed char x_flag_schedule_speculative_load;
signed char x_flag_schedule_speculative_load_dangerous;
signed char x_flag_sched2_use_superblocks;
signed char x_flag_schedule_fusion;
signed char x_flag_schedule_insns;
signed char x_flag_schedule_insns_after_reload;
signed char x_flag_section_anchors;
signed char x_flag_sel_sched_pipelining;
signed char x_flag_sel_sched_pipelining_outer_loops;
signed char x_flag_sel_sched_reschedule_pipelined;
signed char x_flag_selective_scheduling;
signed char x_flag_selective_scheduling2;
signed char x_flag_short_enums;
signed char x_flag_short_wchar;
signed char x_flag_shrink_wrap;
signed char x_flag_shrink_wrap_separate;
signed char x_flag_signaling_nans;
signed char x_flag_signed_zeros;
signed char x_flag_single_precision_constant;
signed char x_flag_split_ivs_in_unroller;
signed char x_flag_split_loops;
signed char x_flag_split_paths;
signed char x_flag_split_wide_types;
signed char x_flag_split_wide_types_early;
signed char x_flag_ssa_backprop;
signed char x_flag_ssa_phiopt;
signed char x_flag_stack_clash_protection;
signed char x_flag_stack_protect;
signed char x_flag_stdarg_opt;
signed char x_flag_store_merging;
signed char x_flag_strict_aliasing;
signed char x_flag_strict_enums;
signed char x_flag_strict_volatile_bitfields;
signed char x_flag_thread_jumps;
signed char x_flag_threadsafe_statics;
signed char x_flag_toplevel_reorder;
signed char x_flag_tracer;
signed char x_flag_trapping_math;
signed char x_flag_trapv;
signed char x_flag_tree_bit_ccp;
signed char x_flag_tree_builtin_call_dce;
signed char x_flag_tree_ccp;
signed char x_flag_tree_ch;
signed char x_flag_tree_coalesce_vars;
signed char x_flag_tree_copy_prop;
signed char x_flag_tree_cselim;
signed char x_flag_tree_dce;
signed char x_flag_tree_dom;
signed char x_flag_tree_dse;
signed char x_flag_tree_forwprop;
signed char x_flag_tree_fre;
signed char x_flag_tree_loop_distribute_patterns;
signed char x_flag_tree_loop_distribution;
signed char x_flag_tree_loop_if_convert;
signed char x_flag_tree_loop_im;
signed char x_flag_tree_loop_ivcanon;
signed char x_flag_tree_loop_optimize;
signed char x_flag_tree_loop_vectorize;
signed char x_flag_tree_live_range_split;
signed char x_flag_tree_partial_pre;
signed char x_flag_tree_phiprop;
signed char x_flag_tree_pre;
signed char x_flag_tree_pta;
signed char x_flag_tree_reassoc;
signed char x_flag_tree_scev_cprop;
signed char x_flag_tree_sink;
signed char x_flag_tree_slp_vectorize;
signed char x_flag_tree_slsr;
signed char x_flag_tree_sra;
signed char x_flag_tree_switch_conversion;
signed char x_flag_tree_tail_merge;
signed char x_flag_tree_ter;
signed char x_flag_tree_vrp;
signed char x_flag_unconstrained_commons;
signed char x_flag_unroll_all_loops;
signed char x_flag_cunroll_grow_size;
signed char x_flag_unroll_loops;
signed char x_flag_unsafe_math_optimizations;
signed char x_flag_unswitch_loops;
signed char x_flag_unwind_tables;
signed char x_flag_var_tracking;
signed char x_flag_var_tracking_assignments;
signed char x_flag_var_tracking_assignments_toggle;
signed char x_flag_var_tracking_uninit;
signed char x_flag_variable_expansion_in_unroller;
signed char x_flag_version_loops_for_strides;
signed char x_flag_value_profile_transformations;
signed char x_flag_web;
signed char x_flag_wrapv;
signed char x_flag_wrapv_pointer;
};
struct cl_target_option
{
long x_ix86_isa_flags2_explicit;
long x_ix86_isa_flags_explicit;
const char *x_ix86_arch_string;
const char *x_ix86_recip_name;
const char *x_ix86_tune_ctrl_string;
const char *x_ix86_tune_memcpy_strategy;
const char *x_ix86_tune_memset_strategy;
const char *x_ix86_tune_string;
long x_ix86_stack_protector_guard_offset;
addr_space_t x_ix86_stack_protector_guard_reg;
int x_target_flags;
long x_ix86_isa_flags;
long x_ix86_isa_flags2;
enum fpmath_unit x_ix86_fpmath;
int x_ix86_target_flags;
enum prefer_vector_width x_prefer_vector_width_type;
enum asm_dialect x_ix86_asm_dialect;
enum calling_abi x_ix86_abi;
enum cmodel x_ix86_cmodel;
enum ix86_veclibabi x_ix86_veclibabi_type;
enum pmode x_ix86_pmode;
enum stack_protector_guard x_ix86_stack_protector_guard;
enum stringop_alg x_ix86_stringop_alg;
enum tls_dialect x_ix86_tls_dialect;
int x_ix86_branch_cost;
int x_ix86_dump_tunes;
int x_ix86_force_align_arg_pointer;
int x_ix86_force_drap;
int x_ix86_incoming_stack_boundary_arg;
int x_ix86_preferred_stack_boundary_arg;
int x_ix86_regparm;
int x_ix86_section_threshold;
int x_ix86_sse2avx;
int x_ix86_tune_no_default;
int x_recip_mask_explicit;
int x_recip_mask;
unsigned char arch;
unsigned char arch_specified;
unsigned char branch_cost;
unsigned char prefetch_sse;
unsigned char schedule;
unsigned char tune;
unsigned char tune_defaulted;
};
extern void cl_optimization_save (struct cl_optimization *, struct gcc_options *);
extern void cl_optimization_restore (struct gcc_options *, struct cl_optimization *);
extern void cl_optimization_print (FILE *, int, struct cl_optimization *);
extern void cl_optimization_print_diff (FILE *, int, cl_optimization *ptr1, cl_optimization *ptr2);
extern void cl_target_option_save (struct cl_target_option *, struct gcc_options *);
extern void cl_target_option_restore (struct gcc_options *, struct cl_target_option *);
extern void cl_target_option_print (FILE *, int, struct cl_target_option *);
extern void cl_target_option_print_diff (FILE *, int, cl_target_option *ptr1, cl_target_option *ptr2);
extern bool cl_target_option_eq (const struct cl_target_option *, const struct cl_target_option *);
extern void cl_target_option_free (struct cl_target_option *);
extern hashval_t cl_target_option_hash (const struct cl_target_option *);
extern hashval_t cl_optimization_hash (const struct cl_optimization *);
extern bool cl_optimization_option_eq (cl_optimization const *ptr1, cl_optimization const *ptr2);
extern void cl_optimization_option_free (cl_optimization *ptr1);
extern void cl_optimization_compare (gcc_options *ptr1, gcc_options *ptr2);
bool
common_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
Ada_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
AdaSCIL_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
AdaWhy_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
BRIG_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
C_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
CXX_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
D_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
Fortran_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
Go_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
LTO_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
LTODump_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
ObjC_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
bool
ObjCXX_handle_option_auto (struct gcc_options *opts,
struct gcc_options *opts_set,
size_t scode, const char *arg,
long value,
unsigned int lang_mask, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc);
void cpp_handle_option_auto (const struct gcc_options * opts, size_t scode,
struct cpp_options * cpp_opts);
void init_global_opts_from_cpp(struct gcc_options * opts,
const struct cpp_options * cpp_opts);
# 8579 "./options.h"
enum opt_code
{
OPT____ = 0,
# 8590 "./options.h"
OPT__completion_ = 9,
# 8610 "./options.h"
OPT__help = 29,
OPT__help_ = 30,
# 8638 "./options.h"
OPT__no_sysroot_suffix = 57,
OPT__output_pch_ = 61,
OPT__param_align_loop_iterations_ = 63,
OPT__param_align_threshold_ = 64,
OPT__param_analyzer_bb_explosion_factor_ = 65,
OPT__param_analyzer_max_enodes_for_full_dump_ = 66,
OPT__param_analyzer_max_enodes_per_program_point_ = 67,
OPT__param_analyzer_max_recursion_depth_ = 68,
OPT__param_analyzer_max_svalue_depth_ = 69,
OPT__param_analyzer_min_snodes_for_call_summary_ = 70,
OPT__param_asan_globals_ = 71,
OPT__param_asan_instrument_allocas_ = 72,
OPT__param_asan_instrument_reads_ = 73,
OPT__param_asan_instrument_writes_ = 74,
OPT__param_asan_instrumentation_with_call_threshold_ = 75,
OPT__param_asan_memintrin_ = 76,
OPT__param_asan_stack_ = 77,
OPT__param_asan_use_after_return_ = 78,
OPT__param_avg_loop_niter_ = 79,
OPT__param_avoid_fma_max_bits_ = 80,
OPT__param_balance_partitions_ = 81,
OPT__param_builtin_expect_probability_ = 82,
OPT__param_builtin_string_cmp_inline_length_ = 83,
OPT__param_case_values_threshold_ = 84,
OPT__param_comdat_sharing_probability_ = 85,
OPT__param_cxx_max_namespaces_for_diagnostic_help_ = 86,
OPT__param_dse_max_alias_queries_per_store_ = 87,
OPT__param_dse_max_object_size_ = 88,
OPT__param_early_inlining_insns_ = 89,
OPT__param_fsm_maximum_phi_arguments_ = 90,
OPT__param_fsm_scale_path_blocks_ = 91,
OPT__param_fsm_scale_path_stmts_ = 92,
OPT__param_gcse_after_reload_critical_fraction_ = 93,
OPT__param_gcse_after_reload_partial_fraction_ = 94,
OPT__param_gcse_cost_distance_ratio_ = 95,
OPT__param_gcse_unrestricted_cost_ = 96,
OPT__param_ggc_min_expand_ = 97,
OPT__param_ggc_min_heapsize_ = 98,
OPT__param_gimple_fe_computed_hot_bb_threshold_ = 99,
OPT__param_graphite_allow_codegen_errors_ = 100,
OPT__param_graphite_max_arrays_per_scop_ = 101,
OPT__param_graphite_max_nb_scop_params_ = 102,
OPT__param_hash_table_verification_limit_ = 103,
OPT__param_hot_bb_count_fraction_ = 104,
OPT__param_hot_bb_count_ws_permille_ = 105,
OPT__param_hot_bb_frequency_fraction_ = 106,
OPT__param_inline_heuristics_hint_percent_ = 107,
OPT__param_inline_min_speedup_ = 108,
OPT__param_inline_unit_growth_ = 109,
OPT__param_integer_share_limit_ = 110,
OPT__param_ipa_cp_eval_threshold_ = 111,
OPT__param_ipa_cp_loop_hint_bonus_ = 112,
OPT__param_ipa_cp_max_recursive_depth_ = 113,
OPT__param_ipa_cp_min_recursive_probability_ = 114,
OPT__param_ipa_cp_recursion_penalty_ = 115,
OPT__param_ipa_cp_single_call_penalty_ = 116,
OPT__param_ipa_cp_unit_growth_ = 117,
OPT__param_ipa_cp_value_list_size_ = 118,
OPT__param_ipa_max_aa_steps_ = 119,
OPT__param_ipa_max_agg_items_ = 120,
OPT__param_ipa_max_param_expr_ops_ = 121,
OPT__param_ipa_max_switch_predicate_bounds_ = 122,
OPT__param_ipa_sra_max_replacements_ = 123,
OPT__param_ipa_sra_ptr_growth_factor_ = 124,
OPT__param_ira_loop_reserved_regs_ = 125,
OPT__param_ira_max_conflict_table_size_ = 126,
OPT__param_ira_max_loops_num_ = 127,
OPT__param_iv_always_prune_cand_set_bound_ = 128,
OPT__param_iv_consider_all_candidates_bound_ = 129,
OPT__param_iv_max_considered_uses_ = 130,
OPT__param_jump_table_max_growth_ratio_for_size_ = 131,
OPT__param_jump_table_max_growth_ratio_for_speed_ = 132,
OPT__param_l1_cache_line_size_ = 133,
OPT__param_l1_cache_size_ = 134,
OPT__param_l2_cache_size_ = 135,
OPT__param_large_function_growth_ = 136,
OPT__param_large_function_insns_ = 137,
OPT__param_large_stack_frame_growth_ = 138,
OPT__param_large_stack_frame_ = 139,
OPT__param_large_unit_insns_ = 140,
OPT__param_lim_expensive_ = 141,
OPT__param_logical_op_non_short_circuit_ = 142,
OPT__param_loop_block_tile_size_ = 143,
OPT__param_loop_interchange_max_num_stmts_ = 144,
OPT__param_loop_interchange_stride_ratio_ = 145,
OPT__param_loop_invariant_max_bbs_in_loop_ = 146,
OPT__param_loop_max_datarefs_for_datadeps_ = 147,
OPT__param_loop_versioning_max_inner_insns_ = 148,
OPT__param_loop_versioning_max_outer_insns_ = 149,
OPT__param_lra_inheritance_ebb_probability_cutoff_ = 150,
OPT__param_lra_max_considered_reload_pseudos_ = 151,
OPT__param_lto_max_partition_ = 152,
OPT__param_lto_max_streaming_parallelism_ = 153,
OPT__param_lto_min_partition_ = 154,
OPT__param_lto_partitions_ = 155,
OPT__param_max_average_unrolled_insns_ = 156,
OPT__param_max_combine_insns_ = 157,
OPT__param_max_completely_peel_loop_nest_depth_ = 158,
OPT__param_max_completely_peel_times_ = 159,
OPT__param_max_completely_peeled_insns_ = 160,
OPT__param_max_crossjump_edges_ = 161,
OPT__param_max_cse_insns_ = 162,
OPT__param_max_cse_path_length_ = 163,
OPT__param_max_cselib_memory_locations_ = 164,
OPT__param_max_debug_marker_count_ = 165,
OPT__param_max_delay_slot_insn_search_ = 166,
OPT__param_max_delay_slot_live_search_ = 167,
OPT__param_max_dse_active_local_stores_ = 168,
OPT__param_max_early_inliner_iterations_ = 169,
OPT__param_max_fields_for_field_sensitive_ = 170,
OPT__param_max_find_base_term_values_ = 171,
OPT__param_max_fsm_thread_length_ = 172,
OPT__param_max_fsm_thread_path_insns_ = 173,
OPT__param_max_fsm_thread_paths_ = 174,
OPT__param_max_gcse_insertion_ratio_ = 175,
OPT__param_max_gcse_memory_ = 176,
OPT__param_max_goto_duplication_insns_ = 177,
OPT__param_max_grow_copy_bb_insns_ = 178,
OPT__param_max_hoist_depth_ = 179,
OPT__param_max_inline_insns_auto_ = 180,
OPT__param_max_inline_insns_recursive_auto_ = 181,
OPT__param_max_inline_insns_recursive_ = 182,
OPT__param_max_inline_insns_single_ = 183,
OPT__param_max_inline_insns_size_ = 184,
OPT__param_max_inline_insns_small_ = 185,
OPT__param_max_inline_recursive_depth_auto_ = 186,
OPT__param_max_inline_recursive_depth_ = 187,
OPT__param_max_isl_operations_ = 188,
OPT__param_max_iterations_computation_cost_ = 189,
OPT__param_max_iterations_to_track_ = 190,
OPT__param_max_jump_thread_duplication_stmts_ = 191,
OPT__param_max_last_value_rtl_ = 192,
OPT__param_max_loop_header_insns_ = 193,
OPT__param_max_modulo_backtrack_attempts_ = 194,
OPT__param_max_partial_antic_length_ = 195,
OPT__param_max_peel_branches_ = 196,
OPT__param_max_peel_times_ = 197,
OPT__param_max_peeled_insns_ = 198,
OPT__param_max_pending_list_length_ = 199,
OPT__param_max_pipeline_region_blocks_ = 200,
OPT__param_max_pipeline_region_insns_ = 201,
OPT__param_max_pow_sqrt_depth_ = 202,
OPT__param_max_predicted_iterations_ = 203,
OPT__param_max_reload_search_insns_ = 204,
OPT__param_max_rtl_if_conversion_insns_ = 205,
OPT__param_max_rtl_if_conversion_predictable_cost_ = 206,
OPT__param_max_rtl_if_conversion_unpredictable_cost_ = 207,
OPT__param_max_sched_extend_regions_iters_ = 208,
OPT__param_max_sched_insn_conflict_delay_ = 209,
OPT__param_max_sched_ready_insns_ = 210,
OPT__param_max_sched_region_blocks_ = 211,
OPT__param_max_sched_region_insns_ = 212,
OPT__param_max_slsr_cand_scan_ = 213,
OPT__param_max_speculative_devirt_maydefs_ = 214,
OPT__param_max_ssa_name_query_depth_ = 215,
OPT__param_max_stores_to_merge_ = 216,
OPT__param_max_stores_to_sink_ = 217,
OPT__param_max_tail_merge_comparisons_ = 218,
OPT__param_max_tail_merge_iterations_ = 219,
OPT__param_max_tracked_strlens_ = 220,
OPT__param_max_tree_if_conversion_phi_args_ = 221,
OPT__param_max_unroll_times_ = 222,
OPT__param_max_unrolled_insns_ = 223,
OPT__param_max_unswitch_insns_ = 224,
OPT__param_max_unswitch_level_ = 225,
OPT__param_max_variable_expansions_in_unroller_ = 226,
OPT__param_max_vartrack_expr_depth_ = 227,
OPT__param_max_vartrack_reverse_op_size_ = 228,
OPT__param_max_vartrack_size_ = 229,
OPT__param_max_vrp_switch_assertions_ = 230,
OPT__param_min_crossjump_insns_ = 231,
OPT__param_min_inline_recursive_probability_ = 232,
OPT__param_min_insn_to_prefetch_ratio_ = 233,
OPT__param_min_loop_cond_split_prob_ = 234,
OPT__param_min_nondebug_insn_uid_ = 235,
OPT__param_min_size_for_stack_sharing_ = 236,
OPT__param_min_spec_prob_ = 237,
OPT__param_min_vect_loop_bound_ = 238,
OPT__param_parloops_chunk_size_ = 239,
OPT__param_parloops_min_per_thread_ = 240,
OPT__param_parloops_schedule_ = 241,
OPT__param_partial_inlining_entry_probability_ = 242,
OPT__param_predictable_branch_outcome_ = 243,
OPT__param_prefetch_dynamic_strides_ = 244,
OPT__param_prefetch_latency_ = 245,
OPT__param_prefetch_min_insn_to_mem_ratio_ = 246,
OPT__param_prefetch_minimum_stride_ = 247,
OPT__param_profile_func_internal_id_ = 248,
OPT__param_promote_statics_ = 249,
OPT__param_rpo_vn_max_loop_depth_ = 250,
OPT__param_sccvn_max_alias_queries_per_access_ = 251,
OPT__param_scev_max_expr_complexity_ = 252,
OPT__param_scev_max_expr_size_ = 253,
OPT__param_sched_autopref_queue_depth_ = 254,
OPT__param_sched_mem_true_dep_cost_ = 255,
OPT__param_sched_pressure_algorithm_ = 256,
OPT__param_sched_spec_prob_cutoff_ = 257,
OPT__param_sched_state_edge_prob_cutoff_ = 258,
OPT__param_selsched_insns_to_rename_ = 259,
OPT__param_selsched_max_lookahead_ = 260,
OPT__param_selsched_max_sched_times_ = 261,
OPT__param_simultaneous_prefetches_ = 262,
OPT__param_sink_frequency_threshold_ = 263,
OPT__param_slp_max_insns_in_bb_ = 264,
OPT__param_sms_dfa_history_ = 265,
OPT__param_sms_loop_average_count_threshold_ = 266,
OPT__param_sms_max_ii_factor_ = 267,
OPT__param_sms_min_sc_ = 268,
OPT__param_sra_max_propagations_ = 269,
OPT__param_sra_max_scalarization_size_Osize_ = 270,
OPT__param_sra_max_scalarization_size_Ospeed_ = 271,
OPT__param_ssa_name_def_chain_limit_ = 272,
OPT__param_ssp_buffer_size_ = 273,
OPT__param_stack_clash_protection_guard_size_ = 274,
OPT__param_stack_clash_protection_probe_interval_ = 275,
OPT__param_store_merging_allow_unaligned_ = 276,
OPT__param_store_merging_max_size_ = 277,
OPT__param_switch_conversion_max_branch_ratio_ = 278,
OPT__param_tm_max_aggregate_size_ = 279,
OPT__param_tracer_dynamic_coverage_feedback_ = 280,
OPT__param_tracer_dynamic_coverage_ = 281,
OPT__param_tracer_max_code_growth_ = 282,
OPT__param_tracer_min_branch_probability_feedback_ = 283,
OPT__param_tracer_min_branch_probability_ = 284,
OPT__param_tracer_min_branch_ratio_ = 285,
OPT__param_tree_reassoc_width_ = 286,
OPT__param_tsan_distinguish_volatile_ = 287,
OPT__param_tsan_instrument_func_entry_exit_ = 288,
OPT__param_uninit_control_dep_attempts_ = 289,
OPT__param_uninlined_function_insns_ = 290,
OPT__param_uninlined_function_time_ = 291,
OPT__param_uninlined_thunk_insns_ = 292,
OPT__param_uninlined_thunk_time_ = 293,
OPT__param_unlikely_bb_count_fraction_ = 294,
OPT__param_unroll_jam_max_unroll_ = 295,
OPT__param_unroll_jam_min_percent_ = 296,
OPT__param_use_after_scope_direct_emission_threshold_ = 297,
OPT__param_use_canonical_types_ = 298,
OPT__param_vect_epilogues_nomask_ = 299,
OPT__param_vect_max_peeling_for_alignment_ = 300,
OPT__param_vect_max_version_for_alias_checks_ = 301,
OPT__param_vect_max_version_for_alignment_checks_ = 302,
OPT__param_vect_partial_vector_usage_ = 303,
# 8915 "./options.h"
OPT__sysroot_ = 334,
OPT__target_help = 335,
# 8926 "./options.h"
OPT__version = 345,
OPT_A = 348,
OPT_B = 349,
OPT_C = 350,
OPT_CC = 351,
OPT_D = 352,
OPT_E = 353,
OPT_F = 354,
OPT_H = 355,
OPT_Hd = 356,
OPT_Hf = 357,
OPT_I = 358,
OPT_J = 359,
OPT_L = 360,
OPT_M = 361,
OPT_MD = 362,
OPT_MF = 363,
OPT_MG = 364,
OPT_MM = 365,
OPT_MMD = 366,
OPT_MP = 367,
OPT_MQ = 368,
OPT_MT = 369,
OPT_N = 370,
OPT_O = 371,
OPT_Ofast = 372,
OPT_Og = 373,
OPT_Os = 374,
OPT_P = 375,
OPT_Q = 376,
OPT_Qn = 377,
OPT_Qy = 378,
OPT_R = 379,
OPT_S = 380,
OPT_T = 381,
OPT_Tbss = 382,
OPT_Tbss_ = 383,
OPT_Tdata = 384,
OPT_Tdata_ = 385,
OPT_Ttext = 386,
OPT_Ttext_ = 387,
OPT_U = 388,
OPT_Wa_ = 390,
OPT_Wabi = 391,
OPT_Wabi_tag = 392,
OPT_Wabi_ = 393,
OPT_Wabsolute_value = 394,
OPT_Waddress = 395,
OPT_Waddress_of_packed_member = 396,
OPT_Waggregate_return = 397,
OPT_Waggressive_loop_optimizations = 398,
OPT_Waliasing = 399,
OPT_Walign_commons = 400,
OPT_Waligned_new_ = 402,
OPT_Wall = 403,
OPT_Walloc_size_larger_than_ = 404,
OPT_Walloc_zero = 405,
OPT_Walloca = 406,
OPT_Walloca_larger_than_ = 407,
OPT_Wampersand = 408,
OPT_Wanalyzer_double_fclose = 409,
OPT_Wanalyzer_double_free = 410,
OPT_Wanalyzer_exposure_through_output_file = 411,
OPT_Wanalyzer_file_leak = 412,
OPT_Wanalyzer_free_of_non_heap = 413,
OPT_Wanalyzer_malloc_leak = 414,
OPT_Wanalyzer_null_argument = 415,
OPT_Wanalyzer_null_dereference = 416,
OPT_Wanalyzer_possible_null_argument = 417,
OPT_Wanalyzer_possible_null_dereference = 418,
OPT_Wanalyzer_stale_setjmp_buffer = 419,
OPT_Wanalyzer_tainted_array_index = 420,
OPT_Wanalyzer_too_complex = 421,
OPT_Wanalyzer_unsafe_call_within_signal_handler = 422,
OPT_Wanalyzer_use_after_free = 423,
OPT_Wanalyzer_use_of_pointer_in_stale_stack_frame = 424,
OPT_Wargument_mismatch = 425,
OPT_Warith_conversion = 426,
OPT_Warray_bounds = 427,
OPT_Warray_bounds_ = 428,
OPT_Warray_temporaries = 429,
OPT_Wassign_intercept = 430,
OPT_Wattribute_alias_ = 432,
OPT_Wattribute_warning = 433,
OPT_Wattributes = 434,
OPT_Wbad_function_cast = 435,
OPT_Wbool_compare = 436,
OPT_Wbool_operation = 437,
OPT_Wbuiltin_declaration_mismatch = 438,
OPT_Wbuiltin_macro_redefined = 439,
OPT_Wc___compat = 440,
OPT_Wc__11_compat = 442,
OPT_Wc__14_compat = 443,
OPT_Wc__17_compat = 444,
OPT_Wc__20_compat = 446,
OPT_Wc_binding_type = 448,
OPT_Wc11_c2x_compat = 449,
OPT_Wc90_c99_compat = 450,
OPT_Wc99_c11_compat = 451,
OPT_Wcannot_profile = 452,
OPT_Wcast_align = 453,
OPT_Wcast_align_strict = 454,
OPT_Wcast_function_type = 455,
OPT_Wcast_qual = 456,
OPT_Wcast_result = 457,
OPT_Wcatch_value_ = 459,
OPT_Wchar_subscripts = 460,
OPT_Wcharacter_truncation = 461,
OPT_Wchkp = 462,
OPT_Wclass_conversion = 463,
OPT_Wclass_memaccess = 464,
OPT_Wclobbered = 465,
OPT_Wcomma_subscript = 466,
OPT_Wcomment = 467,
OPT_Wcompare_reals = 469,
OPT_Wconditionally_supported = 470,
OPT_Wconversion = 471,
OPT_Wconversion_extra = 472,
OPT_Wconversion_null = 473,
OPT_Wcoverage_mismatch = 474,
OPT_Wcpp = 475,
OPT_Wctor_dtor_privacy = 476,
OPT_Wdangling_else = 477,
OPT_Wdate_time = 478,
OPT_Wdeclaration_after_statement = 479,
OPT_Wdelete_incomplete = 480,
OPT_Wdelete_non_virtual_dtor = 481,
OPT_Wdeprecated = 482,
OPT_Wdeprecated_copy = 483,
OPT_Wdeprecated_copy_dtor = 484,
OPT_Wdeprecated_declarations = 485,
OPT_Wdesignated_init = 486,
OPT_Wdisabled_optimization = 487,
OPT_Wdiscarded_array_qualifiers = 488,
OPT_Wdiscarded_qualifiers = 489,
OPT_Wdiv_by_zero = 490,
OPT_Wdo_subscript = 491,
OPT_Wdouble_promotion = 492,
OPT_Wduplicate_decl_specifier = 493,
OPT_Wduplicated_branches = 494,
OPT_Wduplicated_cond = 495,
OPT_Weffc__ = 496,
OPT_Wempty_body = 497,
OPT_Wendif_labels = 498,
OPT_Wenum_compare = 499,
OPT_Wenum_conversion = 500,
OPT_Werror = 501,
OPT_Werror_ = 503,
OPT_Wexpansion_to_defined = 504,
OPT_Wextra = 505,
OPT_Wextra_semi = 506,
OPT_Wfatal_errors = 507,
OPT_Wfloat_conversion = 508,
OPT_Wfloat_equal = 509,
OPT_Wformat_contains_nul = 511,
OPT_Wformat_diag = 512,
OPT_Wformat_extra_args = 513,
OPT_Wformat_nonliteral = 514,
OPT_Wformat_overflow_ = 516,
OPT_Wformat_security = 517,
OPT_Wformat_signedness = 518,
OPT_Wformat_truncation_ = 520,
OPT_Wformat_y2k = 521,
OPT_Wformat_zero_length = 522,
OPT_Wformat_ = 523,
OPT_Wframe_address = 524,
OPT_Wframe_larger_than_ = 525,
OPT_Wfree_nonheap_object = 526,
OPT_Wfrontend_loop_interchange = 527,
OPT_Wfunction_elimination = 528,
OPT_Wif_not_aligned = 530,
OPT_Wignored_attributes = 531,
OPT_Wignored_qualifiers = 532,
OPT_Wimplicit = 533,
OPT_Wimplicit_fallthrough_ = 535,
OPT_Wimplicit_function_declaration = 536,
OPT_Wimplicit_int = 537,
OPT_Wimplicit_interface = 538,
OPT_Wimplicit_procedure = 539,
OPT_Winaccessible_base = 541,
OPT_Wincompatible_pointer_types = 542,
OPT_Winherited_variadic_ctor = 543,
OPT_Winit_list_lifetime = 544,
OPT_Winit_self = 545,
OPT_Winline = 546,
OPT_Wint_conversion = 547,
OPT_Wint_in_bool_context = 548,
OPT_Wint_to_pointer_cast = 549,
OPT_Winteger_division = 550,
OPT_Wintrinsic_shadow = 551,
OPT_Wintrinsics_std = 552,
OPT_Winvalid_memory_model = 553,
OPT_Winvalid_offsetof = 554,
OPT_Winvalid_pch = 555,
OPT_Wjump_misses_init = 556,
OPT_Wl_ = 557,
OPT_Wlarger_than_ = 559,
OPT_Wline_truncation = 560,
OPT_Wliteral_suffix = 561,
OPT_Wlogical_not_parentheses = 562,
OPT_Wlogical_op = 563,
OPT_Wlong_long = 564,
OPT_Wlto_type_mismatch = 565,
OPT_Wmain = 566,
OPT_Wmaybe_uninitialized = 567,
OPT_Wmemset_elt_size = 568,
OPT_Wmemset_transposed_args = 569,
OPT_Wmisleading_indentation = 570,
OPT_Wmismatched_tags = 571,
OPT_Wmissing_attributes = 572,
OPT_Wmissing_braces = 573,
OPT_Wmissing_declarations = 574,
OPT_Wmissing_field_initializers = 575,
OPT_Wmissing_include_dirs = 577,
OPT_Wmissing_parameter_type = 579,
OPT_Wmissing_profile = 580,
OPT_Wmissing_prototypes = 581,
OPT_Wmudflap = 582,
OPT_Wmultichar = 583,
OPT_Wmultiple_inheritance = 584,
OPT_Wmultistatement_macros = 585,
OPT_Wnamespaces = 586,
OPT_Wnarrowing = 587,
OPT_Wnested_externs = 588,
OPT_Wnoexcept = 595,
OPT_Wnoexcept_type = 596,
OPT_Wnon_template_friend = 597,
OPT_Wnon_virtual_dtor = 598,
OPT_Wnonnull = 599,
OPT_Wnonnull_compare = 600,
OPT_Wnormalized_ = 602,
OPT_Wnull_dereference = 603,
OPT_Wodr = 604,
OPT_Wold_style_cast = 605,
OPT_Wold_style_declaration = 606,
OPT_Wold_style_definition = 607,
OPT_Wopenmp_simd = 608,
OPT_Woverflow = 609,
OPT_Woverlength_strings = 610,
OPT_Woverloaded_virtual = 611,
OPT_Woverride_init = 612,
OPT_Woverride_init_side_effects = 613,
OPT_Woverwrite_recursive = 614,
OPT_Wp_ = 615,
OPT_Wpacked = 616,
OPT_Wpacked_bitfield_compat = 617,
OPT_Wpacked_not_aligned = 618,
OPT_Wpadded = 619,
OPT_Wparentheses = 620,
OPT_Wpedantic = 621,
OPT_Wpessimizing_move = 622,
OPT_Wplacement_new_ = 624,
OPT_Wpmf_conversions = 625,
OPT_Wpointer_arith = 626,
OPT_Wpointer_compare = 627,
OPT_Wpointer_sign = 628,
OPT_Wpointer_to_int_cast = 629,
OPT_Wpragmas = 630,
OPT_Wprio_ctor_dtor = 631,
OPT_Wproperty_assign_default = 632,
OPT_Wprotocol = 633,
OPT_Wpsabi = 634,
OPT_Wreal_q_constant = 635,
OPT_Wrealloc_lhs = 636,
OPT_Wrealloc_lhs_all = 637,
OPT_Wredundant_decls = 638,
OPT_Wredundant_move = 639,
OPT_Wredundant_tags = 640,
OPT_Wregister = 641,
OPT_Wreorder = 642,
OPT_Wrestrict = 643,
OPT_Wreturn_local_addr = 644,
OPT_Wreturn_type = 645,
OPT_Wscalar_storage_order = 646,
OPT_Wselector = 647,
OPT_Wsequence_point = 648,
OPT_Wshadow = 649,
OPT_Wshadow_ivar = 651,
OPT_Wshadow_compatible_local = 653,
OPT_Wshadow_local = 655,
OPT_Wshift_count_negative = 656,
OPT_Wshift_count_overflow = 657,
OPT_Wshift_negative_value = 658,
OPT_Wshift_overflow_ = 660,
OPT_Wsign_compare = 661,
OPT_Wsign_conversion = 662,
OPT_Wsign_promo = 663,
OPT_Wsized_deallocation = 664,
OPT_Wsizeof_array_argument = 665,
OPT_Wsizeof_pointer_div = 666,
OPT_Wsizeof_pointer_memaccess = 667,
OPT_Wspeculative = 668,
OPT_Wstack_protector = 669,
OPT_Wstack_usage_ = 670,
OPT_Wstrict_aliasing = 671,
OPT_Wstrict_aliasing_ = 672,
OPT_Wstrict_null_sentinel = 673,
OPT_Wstrict_overflow = 674,
OPT_Wstrict_overflow_ = 675,
OPT_Wstrict_prototypes = 676,
OPT_Wstrict_selector_match = 677,
OPT_Wstring_compare = 678,
OPT_Wstringop_overflow_ = 680,
OPT_Wstringop_truncation = 681,
OPT_Wsubobject_linkage = 682,
OPT_Wsuggest_attribute_cold = 683,
OPT_Wsuggest_attribute_const = 684,
OPT_Wsuggest_attribute_format = 685,
OPT_Wsuggest_attribute_malloc = 686,
OPT_Wsuggest_attribute_noreturn = 687,
OPT_Wsuggest_attribute_pure = 688,
OPT_Wsuggest_final_methods = 689,
OPT_Wsuggest_final_types = 690,
OPT_Wsuggest_override = 691,
OPT_Wsurprising = 692,
OPT_Wswitch = 693,
OPT_Wswitch_bool = 694,
OPT_Wswitch_default = 695,
OPT_Wswitch_enum = 696,
OPT_Wswitch_outside_range = 697,
OPT_Wswitch_unreachable = 698,
OPT_Wsync_nand = 699,
OPT_Wsynth = 700,
OPT_Wsystem_headers = 701,
OPT_Wtabs = 702,
OPT_Wtarget_lifetime = 703,
OPT_Wtautological_compare = 704,
OPT_Wtemplates = 705,
OPT_Wterminate = 706,
OPT_Wtraditional = 707,
OPT_Wtraditional_conversion = 708,
OPT_Wtrampolines = 709,
OPT_Wtrigraphs = 710,
OPT_Wtype_limits = 711,
OPT_Wundeclared_selector = 712,
OPT_Wundef = 713,
OPT_Wundefined_do_loop = 714,
OPT_Wunderflow = 715,
OPT_Wuninitialized = 716,
OPT_Wunknown_pragmas = 717,
OPT_Wunsuffixed_float_constants = 720,
OPT_Wunused = 721,
OPT_Wunused_but_set_parameter = 722,
OPT_Wunused_but_set_variable = 723,
OPT_Wunused_const_variable_ = 725,
OPT_Wunused_dummy_argument = 726,
OPT_Wunused_function = 727,
OPT_Wunused_label = 728,
OPT_Wunused_local_typedefs = 729,
OPT_Wunused_macros = 730,
OPT_Wunused_parameter = 731,
OPT_Wunused_result = 732,
OPT_Wunused_value = 733,
OPT_Wunused_variable = 734,
OPT_Wuse_without_only = 735,
OPT_Wuseless_cast = 736,
OPT_Wvarargs = 737,
OPT_Wvariadic_macros = 738,
OPT_Wvector_operation_performance = 739,
OPT_Wvirtual_inheritance = 740,
OPT_Wvirtual_move_assign = 741,
OPT_Wvla = 742,
OPT_Wvla_larger_than_ = 743,
OPT_Wvolatile = 744,
OPT_Wvolatile_register_var = 745,
OPT_Wwrite_strings = 746,
OPT_Wzero_as_null_pointer_constant = 747,
OPT_Wzero_length_bounds = 748,
OPT_Wzerotrip = 749,
OPT_X = 750,
OPT_Xassembler = 751,
OPT_Xf = 752,
OPT_Xlinker = 753,
OPT_Xpreprocessor = 754,
OPT_Z = 755,
OPT_ansi = 756,
OPT_aux_info = 757,
OPT_c = 759,
OPT_callgraph = 760,
OPT_coverage = 761,
OPT_cpp = 762,
OPT_cpp_ = 763,
OPT_d = 764,
OPT_debuglib_ = 765,
OPT_defaultlib_ = 766,
OPT_defined_only = 767,
OPT_demangle = 768,
OPT_dstartfiles = 769,
OPT_dump_body_ = 770,
OPT_dump_level_ = 771,
OPT_dumpbase = 772,
OPT_dumpbase_ext = 773,
OPT_dumpdir = 774,
OPT_dumpfullversion = 775,
OPT_dumpmachine = 776,
OPT_dumpspecs = 777,
OPT_dumpversion = 778,
OPT_e = 779,
OPT_export_dynamic = 780,
OPT_fPIC = 781,
OPT_fPIE = 782,
OPT_fRTS_ = 783,
OPT_fabi_compat_version_ = 784,
OPT_fabi_version_ = 785,
OPT_faccess_control = 786,
OPT_fada_spec_parent_ = 787,
OPT_faggressive_function_elimination = 788,
OPT_faggressive_loop_optimizations = 789,
OPT_falign_commons = 790,
OPT_falign_functions = 791,
OPT_falign_functions_ = 792,
OPT_falign_jumps = 793,
OPT_falign_jumps_ = 794,
OPT_falign_labels = 795,
OPT_falign_labels_ = 796,
OPT_falign_loops = 797,
OPT_falign_loops_ = 798,
OPT_faligned_new_ = 800,
OPT_fall_instantiations = 801,
OPT_fall_intrinsics = 802,
OPT_fall_virtual = 803,
OPT_fallocation_dce = 804,
OPT_fallow_argument_mismatch = 805,
OPT_fallow_invalid_boz = 806,
OPT_fallow_leading_underscore = 807,
OPT_fallow_parameterless_variadic_functions = 808,
OPT_fallow_store_data_races = 809,
OPT_falt_external_templates = 810,
OPT_fanalyzer = 811,
OPT_fanalyzer_call_summaries = 812,
OPT_fanalyzer_checker_ = 813,
OPT_fanalyzer_fine_grained = 814,
OPT_fanalyzer_show_duplicate_count = 815,
OPT_fanalyzer_state_merge = 816,
OPT_fanalyzer_state_purge = 817,
OPT_fanalyzer_transitivity = 818,
OPT_fanalyzer_verbose_edges = 819,
OPT_fanalyzer_verbose_state_changes = 820,
OPT_fanalyzer_verbosity_ = 821,
OPT_fasan_shadow_offset_ = 826,
OPT_fasm = 827,
OPT_fassert = 828,
OPT_fassociative_math = 829,
OPT_fassume_phsa = 830,
OPT_fasynchronous_unwind_tables = 831,
OPT_fauto_inc_dec = 832,
OPT_fauto_profile = 833,
OPT_fauto_profile_ = 834,
OPT_fautomatic = 835,
OPT_fbackslash = 836,
OPT_fbacktrace = 837,
OPT_fblas_matmul_limit_ = 838,
OPT_fbounds_check = 839,
OPT_fbounds_check_ = 840,
OPT_fbranch_count_reg = 841,
OPT_fbranch_probabilities = 842,
OPT_fbuilding_libgcc = 846,
OPT_fbuilding_libphobos_tests = 847,
OPT_fbuiltin = 848,
OPT_fbuiltin_ = 849,
OPT_fbuiltin_printf = 850,
OPT_fc_prototypes = 851,
OPT_fc_prototypes_external = 852,
OPT_fcall_saved_ = 853,
OPT_fcall_used_ = 854,
OPT_fcaller_saves = 855,
OPT_fcallgraph_info = 856,
OPT_fcallgraph_info_ = 857,
OPT_fcanonical_system_headers = 858,
OPT_fcf_protection_ = 860,
OPT_fchar8_t = 861,
OPT_fcheck_array_temporaries = 862,
OPT_fcheck_new = 864,
OPT_fcheck_pointer_bounds = 865,
OPT_fcheck_ = 866,
OPT_fchecking = 867,
OPT_fchecking_ = 868,
OPT_fchkp_check_incomplete_type = 869,
OPT_fchkp_check_read = 870,
OPT_fchkp_check_write = 871,
OPT_fchkp_first_field_has_own_bounds = 872,
OPT_fchkp_flexible_struct_trailing_arrays = 873,
OPT_fchkp_instrument_calls = 874,
OPT_fchkp_instrument_marked_only = 875,
OPT_fchkp_narrow_bounds = 876,
OPT_fchkp_narrow_to_innermost_array = 877,
OPT_fchkp_optimize = 878,
OPT_fchkp_store_bounds = 879,
OPT_fchkp_treat_zero_dynamic_size_as_infinite = 880,
OPT_fchkp_use_fast_string_functions = 881,
OPT_fchkp_use_nochk_string_functions = 882,
OPT_fchkp_use_static_bounds = 883,
OPT_fchkp_use_static_const_bounds = 884,
OPT_fchkp_use_wrappers = 885,
OPT_fchkp_zero_input_bounds_for_main = 886,
OPT_fcoarray_ = 888,
OPT_fcode_hoisting = 889,
OPT_fcombine_stack_adjustments = 890,
OPT_fcommon = 891,
OPT_fcompare_debug = 892,
OPT_fcompare_debug_second = 893,
OPT_fcompare_debug_ = 894,
OPT_fcompare_elim = 895,
OPT_fconcepts = 896,
OPT_fconcepts_diagnostics_depth_ = 897,
OPT_fconcepts_ts = 898,
OPT_fcond_mismatch = 899,
OPT_fconserve_stack = 901,
OPT_fconstant_string_class_ = 902,
OPT_fconstexpr_cache_depth_ = 903,
OPT_fconstexpr_depth_ = 904,
OPT_fconstexpr_loop_limit_ = 905,
OPT_fconstexpr_ops_limit_ = 906,
OPT_fconvert_ = 907,
OPT_fcoroutines = 908,
OPT_fcprop_registers = 909,
OPT_fcray_pointer = 910,
OPT_fcrossjumping = 911,
OPT_fcse_follow_jumps = 912,
OPT_fcx_fortran_rules = 914,
OPT_fcx_limited_range = 915,
OPT_fd_lines_as_code = 916,
OPT_fd_lines_as_comments = 917,
OPT_fdata_sections = 918,
OPT_fdbg_cnt_list = 919,
OPT_fdbg_cnt_ = 920,
OPT_fdce = 921,
OPT_fdebug = 922,
OPT_fdebug_cpp = 923,
OPT_fdebug_prefix_map_ = 924,
OPT_fdebug_types_section = 925,
OPT_fdebug_ = 926,
OPT_fdec = 927,
OPT_fdec_blank_format_item = 928,
OPT_fdec_char_conversions = 929,
OPT_fdec_format_defaults = 930,
OPT_fdec_include = 931,
OPT_fdec_intrinsic_ints = 932,
OPT_fdec_math = 933,
OPT_fdec_static = 934,
OPT_fdec_structure = 935,
OPT_fdeclone_ctor_dtor = 936,
OPT_fdefault_double_8 = 938,
OPT_fdefault_integer_8 = 940,
OPT_fdefault_real_10 = 941,
OPT_fdefault_real_16 = 942,
OPT_fdefault_real_8 = 943,
OPT_fdefer_pop = 944,
OPT_fdelayed_branch = 945,
OPT_fdelete_dead_exceptions = 946,
OPT_fdelete_null_pointer_checks = 947,
OPT_fdevirtualize = 948,
OPT_fdevirtualize_at_ltrans = 949,
OPT_fdevirtualize_speculatively = 950,
OPT_fdiagnostics_color_ = 952,
OPT_fdiagnostics_column_origin_ = 953,
OPT_fdiagnostics_column_unit_ = 954,
OPT_fdiagnostics_format_ = 955,
OPT_fdiagnostics_generate_patch = 956,
OPT_fdiagnostics_minimum_margin_width_ = 957,
OPT_fdiagnostics_parseable_fixits = 958,
OPT_fdiagnostics_path_format_ = 959,
OPT_fdiagnostics_plain_output = 960,
OPT_fdiagnostics_show_caret = 961,
OPT_fdiagnostics_show_cwe = 962,
OPT_fdiagnostics_show_labels = 963,
OPT_fdiagnostics_show_line_numbers = 964,
OPT_fdiagnostics_show_location_ = 965,
OPT_fdiagnostics_show_option = 966,
OPT_fdiagnostics_show_path_depths = 967,
OPT_fdiagnostics_show_template_tree = 968,
OPT_fdiagnostics_urls_ = 969,
OPT_fdirectives_only = 970,
OPT_fdisable_ = 971,
OPT_fdoc = 972,
OPT_fdoc_dir_ = 973,
OPT_fdoc_file_ = 974,
OPT_fdoc_inc_ = 975,
OPT_fdollar_ok = 976,
OPT_fdollars_in_identifiers = 977,
OPT_fdruntime = 978,
OPT_fdse = 979,
OPT_fdump_ = 980,
OPT_fdump_ada_spec = 981,
OPT_fdump_ada_spec_slim = 982,
OPT_fdump_analyzer = 983,
OPT_fdump_analyzer_callgraph = 984,
OPT_fdump_analyzer_exploded_graph = 985,
OPT_fdump_analyzer_exploded_nodes = 986,
OPT_fdump_analyzer_exploded_nodes_2 = 987,
OPT_fdump_analyzer_exploded_nodes_3 = 988,
OPT_fdump_analyzer_state_purge = 989,
OPT_fdump_analyzer_stderr = 990,
OPT_fdump_analyzer_supergraph = 991,
OPT_fdump_d_original = 993,
OPT_fdump_final_insns = 994,
OPT_fdump_final_insns_ = 995,
OPT_fdump_fortran_global = 996,
OPT_fdump_fortran_optimized = 997,
OPT_fdump_fortran_original = 998,
OPT_fdump_go_spec_ = 999,
OPT_fdump_internal_locations = 1000,
OPT_fdump_noaddr = 1001,
OPT_fdump_passes = 1003,
OPT_fdump_scos = 1004,
OPT_fdump_unnumbered = 1005,
OPT_fdump_unnumbered_links = 1006,
OPT_fdwarf2_cfi_asm = 1007,
OPT_fearly_inlining = 1008,
OPT_felide_constructors = 1009,
OPT_felide_type = 1010,
OPT_feliminate_unused_debug_symbols = 1012,
OPT_feliminate_unused_debug_types = 1013,
OPT_femit_class_debug_always = 1014,
OPT_femit_struct_debug_baseonly = 1015,
OPT_femit_struct_debug_detailed_ = 1016,
OPT_femit_struct_debug_reduced = 1017,
OPT_fenable_ = 1018,
OPT_fenforce_eh_specs = 1019,
OPT_fenum_int_equiv = 1020,
OPT_fexceptions = 1021,
OPT_fexcess_precision_ = 1022,
OPT_fexec_charset_ = 1023,
OPT_fexpensive_optimizations = 1024,
OPT_fext_numeric_literals = 1025,
OPT_fextended_identifiers = 1026,
OPT_fextern_tls_init = 1027,
OPT_fexternal_blas = 1028,
OPT_fexternal_templates = 1029,
OPT_ff2c = 1030,
OPT_ffast_math = 1031,
OPT_ffat_lto_objects = 1032,
OPT_ffile_prefix_map_ = 1033,
OPT_ffinite_loops = 1034,
OPT_ffinite_math_only = 1035,
OPT_ffixed_ = 1036,
OPT_ffixed_form = 1037,
OPT_ffixed_line_length_ = 1038,
OPT_ffixed_line_length_none = 1039,
OPT_ffloat_store = 1040,
OPT_ffor_scope = 1041,
OPT_fforward_propagate = 1043,
OPT_ffp_contract_ = 1044,
OPT_ffp_int_builtin_inexact = 1045,
OPT_ffpe_summary_ = 1046,
OPT_ffpe_trap_ = 1047,
OPT_ffree_form = 1048,
OPT_ffree_line_length_ = 1049,
OPT_ffree_line_length_none = 1050,
OPT_ffreestanding = 1051,
OPT_ffriend_injection = 1052,
OPT_ffrontend_loop_interchange = 1053,
OPT_ffrontend_optimize = 1054,
OPT_ffunction_cse = 1055,
OPT_ffunction_sections = 1056,
OPT_fgcse = 1057,
OPT_fgcse_after_reload = 1058,
OPT_fgcse_las = 1059,
OPT_fgcse_lm = 1060,
OPT_fgcse_sm = 1061,
OPT_fgimple = 1062,
OPT_fgnat_encodings_ = 1063,
OPT_fgnu_keywords = 1064,
OPT_fgnu_runtime = 1065,
OPT_fgnu_tm = 1066,
OPT_fgnu_unique = 1067,
OPT_fgnu89_inline = 1068,
OPT_fgo_c_header_ = 1069,
OPT_fgo_check_divide_overflow = 1070,
OPT_fgo_check_divide_zero = 1071,
OPT_fgo_compiling_runtime = 1072,
OPT_fgo_debug_escape = 1073,
OPT_fgo_debug_escape_hash_ = 1074,
OPT_fgo_debug_optimization = 1075,
OPT_fgo_dump_ = 1076,
OPT_fgo_optimize_ = 1077,
OPT_fgo_pkgpath_ = 1078,
OPT_fgo_prefix_ = 1079,
OPT_fgo_relative_import_path_ = 1080,
OPT_fgraphite = 1081,
OPT_fgraphite_identity = 1082,
OPT_fguess_branch_probability = 1083,
OPT_fguiding_decls = 1084,
OPT_fhoist_adjacent_loads = 1088,
OPT_fhonor_std = 1089,
OPT_fhosted = 1090,
OPT_fhuge_objects = 1091,
OPT_fident = 1092,
OPT_fif_conversion = 1093,
OPT_fif_conversion2 = 1094,
OPT_fignore_unknown_pragmas = 1095,
OPT_fimplement_inlines = 1096,
OPT_fimplicit_inline_templates = 1097,
OPT_fimplicit_none = 1098,
OPT_fimplicit_templates = 1099,
OPT_findirect_inlining = 1100,
OPT_finhibit_size_directive = 1101,
OPT_finit_character_ = 1102,
OPT_finit_derived = 1103,
OPT_finit_integer_ = 1104,
OPT_finit_local_zero = 1105,
OPT_finit_logical_ = 1106,
OPT_finit_real_ = 1107,
OPT_finline = 1108,
OPT_finline_arg_packing = 1109,
OPT_finline_atomics = 1110,
OPT_finline_functions = 1111,
OPT_finline_functions_called_once = 1112,
OPT_finline_limit_ = 1114,
OPT_finline_matmul_limit_ = 1115,
OPT_finline_small_functions = 1116,
OPT_finput_charset_ = 1117,
OPT_finstrument_functions = 1118,
OPT_finstrument_functions_exclude_file_list_ = 1119,
OPT_finstrument_functions_exclude_function_list_ = 1120,
OPT_finteger_4_integer_8 = 1121,
OPT_fintrinsic_modules_path = 1122,
OPT_fintrinsic_modules_path_ = 1123,
OPT_finvariants = 1124,
OPT_fipa_bit_cp = 1125,
OPT_fipa_cp = 1126,
OPT_fipa_cp_clone = 1128,
OPT_fipa_icf = 1129,
OPT_fipa_icf_functions = 1130,
OPT_fipa_icf_variables = 1131,
OPT_fipa_profile = 1133,
OPT_fipa_pta = 1134,
OPT_fipa_pure_const = 1135,
OPT_fipa_ra = 1136,
OPT_fipa_reference = 1137,
OPT_fipa_reference_addressable = 1138,
OPT_fipa_sra = 1139,
OPT_fipa_stack_alignment = 1140,
OPT_fipa_vrp = 1142,
OPT_fira_algorithm_ = 1143,
OPT_fira_hoist_pressure = 1144,
OPT_fira_loop_pressure = 1145,
OPT_fira_region_ = 1146,
OPT_fira_share_save_slots = 1147,
OPT_fira_share_spill_slots = 1148,
OPT_fira_verbose_ = 1149,
OPT_fisolate_erroneous_paths_attribute = 1150,
OPT_fisolate_erroneous_paths_dereference = 1151,
OPT_fivar_visibility_ = 1152,
OPT_fivopts = 1153,
OPT_fjump_tables = 1154,
OPT_fkeep_gc_roots_live = 1155,
OPT_fkeep_inline_dllexport = 1156,
OPT_fkeep_inline_functions = 1157,
OPT_fkeep_static_consts = 1158,
OPT_fkeep_static_functions = 1159,
OPT_flabels_ok = 1160,
OPT_flarge_source_files = 1161,
OPT_flax_vector_conversions = 1162,
OPT_fleading_underscore = 1163,
OPT_flifetime_dse = 1164,
OPT_flifetime_dse_ = 1165,
OPT_flimit_function_alignment = 1166,
OPT_flinker_output_ = 1167,
OPT_flive_patching_ = 1169,
OPT_flive_range_shrinkage = 1170,
OPT_flocal_ivars = 1171,
OPT_floop_interchange = 1174,
OPT_floop_nest_optimize = 1175,
OPT_floop_parallelize_all = 1177,
OPT_floop_unroll_and_jam = 1179,
OPT_flra_remat = 1180,
OPT_flto = 1181,
OPT_flto_compression_level_ = 1182,
OPT_flto_partition_ = 1184,
OPT_flto_report = 1185,
OPT_flto_report_wpa = 1186,
OPT_flto_ = 1187,
OPT_fltrans = 1188,
OPT_fltrans_output_list_ = 1189,
OPT_fmacro_prefix_map_ = 1190,
OPT_fmain = 1191,
OPT_fmath_errno = 1192,
OPT_fmax_array_constructor_ = 1193,
OPT_fmax_errors_ = 1194,
OPT_fmax_identifier_length_ = 1195,
OPT_fmax_include_depth_ = 1196,
OPT_fmax_stack_var_size_ = 1197,
OPT_fmax_subrecord_length_ = 1198,
OPT_fmem_report = 1199,
OPT_fmem_report_wpa = 1200,
OPT_fmerge_all_constants = 1201,
OPT_fmerge_constants = 1202,
OPT_fmerge_debug_strings = 1203,
OPT_fmessage_length_ = 1204,
OPT_fmodule_file_ = 1205,
OPT_fmodule_private = 1206,
OPT_fmoduleinfo = 1207,
OPT_fmodulo_sched = 1208,
OPT_fmodulo_sched_allow_regmoves = 1209,
OPT_fmove_loop_invariants = 1210,
OPT_fms_extensions = 1211,
OPT_fmudflap = 1212,
OPT_fmudflapir = 1213,
OPT_fmudflapth = 1214,
OPT_fname_mangling_version_ = 1215,
OPT_fnew_abi = 1216,
OPT_fnew_inheriting_ctors = 1217,
OPT_fnew_ttp_matching = 1218,
OPT_fnext_runtime = 1219,
OPT_fnil_receivers = 1220,
OPT_fnon_call_exceptions = 1221,
OPT_fnonansi_builtins = 1222,
OPT_fnonnull_objects = 1223,
OPT_fnothrow_opt = 1224,
OPT_fobjc_abi_version_ = 1225,
OPT_fobjc_call_cxx_cdtors = 1226,
OPT_fobjc_direct_dispatch = 1227,
OPT_fobjc_exceptions = 1228,
OPT_fobjc_gc = 1229,
OPT_fobjc_nilcheck = 1230,
OPT_fobjc_sjlj_exceptions = 1231,
OPT_fobjc_std_objc1 = 1232,
OPT_foffload_abi_ = 1233,
OPT_foffload_ = 1234,
OPT_fomit_frame_pointer = 1235,
OPT_fonly_ = 1236,
OPT_fopenacc = 1237,
OPT_fopenacc_dim_ = 1238,
OPT_fopenmp = 1239,
OPT_fopenmp_simd = 1240,
OPT_foperator_names = 1241,
OPT_fopt_info = 1242,
OPT_fopt_info_ = 1243,
OPT_foptimize_sibling_calls = 1245,
OPT_foptimize_strlen = 1246,
OPT_fpack_derived = 1248,
OPT_fpack_struct = 1249,
OPT_fpack_struct_ = 1250,
OPT_fpad_source = 1251,
OPT_fparallel_jobs_ = 1252,
OPT_fpartial_inlining = 1253,
OPT_fpatchable_function_entry_ = 1254,
OPT_fpcc_struct_return = 1255,
OPT_fpch_deps = 1256,
OPT_fpch_preprocess = 1257,
OPT_fpeel_loops = 1258,
OPT_fpeephole = 1259,
OPT_fpeephole2 = 1260,
OPT_fpermissive = 1261,
OPT_fpermitted_flt_eval_methods_ = 1262,
OPT_fpic = 1263,
OPT_fpie = 1264,
OPT_fplan9_extensions = 1265,
OPT_fplt = 1266,
OPT_fplugin_arg_ = 1267,
OPT_fplugin_ = 1268,
OPT_fpost_ipa_mem_report = 1269,
OPT_fpostconditions = 1270,
OPT_fpre_include_ = 1271,
OPT_fpre_ipa_mem_report = 1272,
OPT_fpreconditions = 1273,
OPT_fpredictive_commoning = 1274,
OPT_fprefetch_loop_arrays = 1275,
OPT_fpreprocessed = 1276,
OPT_fpretty_templates = 1277,
OPT_fprintf_return_value = 1278,
OPT_fprofile = 1279,
OPT_fprofile_abs_path = 1280,
OPT_fprofile_arcs = 1281,
OPT_fprofile_correction = 1282,
OPT_fprofile_dir_ = 1283,
OPT_fprofile_exclude_files_ = 1284,
OPT_fprofile_filter_files_ = 1285,
OPT_fprofile_generate = 1286,
OPT_fprofile_generate_ = 1287,
OPT_fprofile_note_ = 1288,
OPT_fprofile_partial_training = 1289,
OPT_fprofile_prefix_path_ = 1290,
OPT_fprofile_reorder_functions = 1291,
OPT_fprofile_report = 1292,
OPT_fprofile_reproducible = 1293,
OPT_fprofile_update_ = 1294,
OPT_fprofile_use = 1295,
OPT_fprofile_use_ = 1296,
OPT_fprofile_values = 1297,
OPT_fprotect_parens = 1298,
OPT_frandom_seed = 1299,
OPT_frandom_seed_ = 1300,
OPT_frange_check = 1301,
OPT_freal_4_real_10 = 1302,
OPT_freal_4_real_16 = 1303,
OPT_freal_4_real_8 = 1304,
OPT_freal_8_real_10 = 1305,
OPT_freal_8_real_16 = 1306,
OPT_freal_8_real_4 = 1307,
OPT_frealloc_lhs = 1308,
OPT_freciprocal_math = 1309,
OPT_frecord_gcc_switches = 1310,
OPT_frecord_marker_4 = 1311,
OPT_frecord_marker_8 = 1312,
OPT_frecursive = 1313,
OPT_free = 1314,
OPT_freg_struct_return = 1315,
OPT_frelease = 1317,
OPT_frename_registers = 1318,
OPT_freorder_blocks = 1319,
OPT_freorder_blocks_algorithm_ = 1320,
OPT_freorder_blocks_and_partition = 1321,
OPT_freorder_functions = 1322,
OPT_frepack_arrays = 1323,
OPT_freplace_objc_classes = 1324,
OPT_frepo = 1325,
OPT_freport_bug = 1326,
OPT_frequire_return_statement = 1327,
OPT_frerun_cse_after_loop = 1328,
OPT_freschedule_modulo_scheduled_loops = 1330,
OPT_fresolution_ = 1331,
OPT_frounding_math = 1332,
OPT_frtti = 1333,
OPT_fsanitize_address_use_after_scope = 1334,
OPT_fsanitize_coverage_ = 1335,
OPT_fsanitize_recover = 1336,
OPT_fsanitize_recover_ = 1337,
OPT_fsanitize_sections_ = 1338,
OPT_fsanitize_undefined_trap_on_error = 1339,
OPT_fsanitize_ = 1340,
OPT_fsave_optimization_record = 1341,
OPT_fsched_critical_path_heuristic = 1342,
OPT_fsched_dep_count_heuristic = 1343,
OPT_fsched_group_heuristic = 1344,
OPT_fsched_interblock = 1345,
OPT_fsched_last_insn_heuristic = 1346,
OPT_fsched_pressure = 1347,
OPT_fsched_rank_heuristic = 1348,
OPT_fsched_spec = 1349,
OPT_fsched_spec_insn_heuristic = 1350,
OPT_fsched_spec_load = 1351,
OPT_fsched_spec_load_dangerous = 1352,
OPT_fsched_stalled_insns = 1353,
OPT_fsched_stalled_insns_dep = 1354,
OPT_fsched_stalled_insns_dep_ = 1355,
OPT_fsched_stalled_insns_ = 1356,
OPT_fsched_verbose_ = 1357,
OPT_fsched2_use_superblocks = 1358,
OPT_fschedule_fusion = 1360,
OPT_fschedule_insns = 1361,
OPT_fschedule_insns2 = 1362,
OPT_fsecond_underscore = 1363,
OPT_fsection_anchors = 1364,
OPT_fsel_sched_pipelining = 1366,
OPT_fsel_sched_pipelining_outer_loops = 1367,
OPT_fsel_sched_reschedule_pipelined = 1368,
OPT_fselective_scheduling = 1369,
OPT_fselective_scheduling2 = 1370,
OPT_fself_test_ = 1371,
OPT_fsemantic_interposition = 1372,
OPT_fshort_enums = 1373,
OPT_fshort_wchar = 1374,
OPT_fshow_column = 1375,
OPT_fshrink_wrap = 1376,
OPT_fshrink_wrap_separate = 1377,
OPT_fsign_zero = 1378,
OPT_fsignaling_nans = 1379,
OPT_fsigned_bitfields = 1380,
OPT_fsigned_char = 1381,
OPT_fsigned_zeros = 1382,
OPT_fsimd_cost_model_ = 1383,
OPT_fsingle_precision_constant = 1384,
OPT_fsized_deallocation = 1385,
OPT_fsplit_ivs_in_unroller = 1386,
OPT_fsplit_loops = 1387,
OPT_fsplit_outputs_ = 1388,
OPT_fsplit_paths = 1389,
OPT_fsplit_stack = 1390,
OPT_fsplit_wide_types = 1391,
OPT_fsplit_wide_types_early = 1392,
OPT_fsquangle = 1393,
OPT_fssa_backprop = 1394,
OPT_fssa_phiopt = 1395,
OPT_fsso_struct_ = 1396,
OPT_fstack_arrays = 1397,
OPT_fstack_check_ = 1399,
OPT_fstack_clash_protection = 1400,
OPT_fstack_limit = 1401,
OPT_fstack_limit_register_ = 1402,
OPT_fstack_limit_symbol_ = 1403,
OPT_fstack_protector = 1404,
OPT_fstack_protector_all = 1405,
OPT_fstack_protector_explicit = 1406,
OPT_fstack_protector_strong = 1407,
OPT_fstack_reuse_ = 1408,
OPT_fstack_usage = 1409,
OPT_fstats = 1410,
OPT_fstdarg_opt = 1411,
OPT_fstore_merging = 1412,
OPT_fstrict_aliasing = 1414,
OPT_fstrict_enums = 1415,
OPT_fstrict_overflow = 1416,
OPT_fstrict_prototype = 1417,
OPT_fstrict_volatile_bitfields = 1418,
OPT_fstrong_eval_order_ = 1420,
OPT_fswitch_errors = 1421,
OPT_fsync_libcalls = 1422,
OPT_fsyntax_only = 1423,
OPT_ftabstop_ = 1424,
OPT_ftail_call_workaround_ = 1426,
OPT_ftemplate_backtrace_limit_ = 1428,
OPT_ftemplate_depth_ = 1430,
OPT_ftest_coverage = 1431,
OPT_ftest_forall_temp = 1432,
OPT_fthis_is_variable = 1433,
OPT_fthread_jumps = 1434,
OPT_fthreadsafe_statics = 1435,
OPT_ftime_report = 1436,
OPT_ftime_report_details = 1437,
OPT_ftls_model_ = 1438,
OPT_ftoplevel_reorder = 1439,
OPT_ftracer = 1440,
OPT_ftrack_macro_expansion = 1441,
OPT_ftrack_macro_expansion_ = 1442,
OPT_ftrampolines = 1443,
OPT_ftransition_all = 1444,
OPT_ftransition_checkimports = 1445,
OPT_ftransition_complex = 1446,
OPT_ftransition_dip1000 = 1447,
OPT_ftransition_dip25 = 1448,
OPT_ftransition_field = 1449,
OPT_ftransition_import = 1450,
OPT_ftransition_nogc = 1451,
OPT_ftransition_tls = 1452,
OPT_ftrapping_math = 1453,
OPT_ftrapv = 1454,
OPT_ftree_bit_ccp = 1455,
OPT_ftree_builtin_call_dce = 1456,
OPT_ftree_ccp = 1457,
OPT_ftree_ch = 1458,
OPT_ftree_coalesce_vars = 1460,
OPT_ftree_copy_prop = 1461,
OPT_ftree_cselim = 1463,
OPT_ftree_dce = 1464,
OPT_ftree_dominator_opts = 1465,
OPT_ftree_dse = 1466,
OPT_ftree_forwprop = 1467,
OPT_ftree_fre = 1468,
OPT_ftree_loop_distribute_patterns = 1469,
OPT_ftree_loop_distribution = 1470,
OPT_ftree_loop_if_convert = 1471,
OPT_ftree_loop_im = 1473,
OPT_ftree_loop_ivcanon = 1474,
OPT_ftree_loop_optimize = 1476,
OPT_ftree_loop_vectorize = 1477,
OPT_ftree_lrs = 1478,
OPT_ftree_parallelize_loops_ = 1479,
OPT_ftree_partial_pre = 1480,
OPT_ftree_phiprop = 1481,
OPT_ftree_pre = 1482,
OPT_ftree_pta = 1483,
OPT_ftree_reassoc = 1484,
OPT_ftree_scev_cprop = 1486,
OPT_ftree_sink = 1487,
OPT_ftree_slp_vectorize = 1488,
OPT_ftree_slsr = 1489,
OPT_ftree_sra = 1490,
OPT_ftree_switch_conversion = 1493,
OPT_ftree_tail_merge = 1494,
OPT_ftree_ter = 1495,
OPT_ftree_vectorize = 1497,
OPT_ftree_vrp = 1499,
OPT_funconstrained_commons = 1500,
OPT_funderscoring = 1501,
OPT_funit_at_a_time = 1502,
OPT_funittest = 1503,
OPT_funroll_all_loops = 1504,
OPT_funroll_completely_grow_size = 1505,
OPT_funroll_loops = 1506,
OPT_funsafe_math_optimizations = 1508,
OPT_funsigned_bitfields = 1509,
OPT_funsigned_char = 1510,
OPT_funswitch_loops = 1511,
OPT_funwind_tables = 1512,
OPT_fuse_cxa_atexit = 1513,
OPT_fuse_cxa_get_exception_ptr = 1514,
OPT_fuse_ld_bfd = 1515,
OPT_fuse_ld_gold = 1516,
OPT_fuse_ld_lld = 1517,
OPT_fuse_linker_plugin = 1518,
OPT_fvar_tracking = 1519,
OPT_fvar_tracking_assignments = 1520,
OPT_fvar_tracking_assignments_toggle = 1521,
OPT_fvar_tracking_uninit = 1522,
OPT_fvariable_expansion_in_unroller = 1523,
OPT_fvect_cost_model_ = 1525,
OPT_fverbose_asm = 1526,
OPT_fversion_loops_for_strides = 1528,
OPT_fversion_ = 1529,
OPT_fvisibility_inlines_hidden = 1530,
OPT_fvisibility_ms_compat = 1531,
OPT_fvisibility_ = 1532,
OPT_fvpt = 1533,
OPT_fvtable_gc = 1534,
OPT_fvtable_thunks = 1535,
OPT_fvtable_verify_ = 1536,
OPT_fvtv_counts = 1537,
OPT_fvtv_debug = 1538,
OPT_fweak = 1539,
OPT_fweb = 1540,
OPT_fwhole_program = 1542,
OPT_fwide_exec_charset_ = 1543,
OPT_fworking_directory = 1544,
OPT_fwpa = 1545,
OPT_fwpa_ = 1546,
OPT_fwrapv = 1547,
OPT_fwrapv_pointer = 1548,
OPT_fxref = 1549,
OPT_fzero_initialized_in_bss = 1551,
OPT_fzero_link = 1552,
OPT_g = 1553,
OPT_gant = 1554,
OPT_gas_loc_support = 1555,
OPT_gas_locview_support = 1556,
OPT_gcoff = 1557,
OPT_gcoff1 = 1558,
OPT_gcoff2 = 1559,
OPT_gcoff3 = 1560,
OPT_gcolumn_info = 1561,
OPT_gdescribe_dies = 1562,
OPT_gdwarf = 1563,
OPT_gdwarf_ = 1564,
OPT_gen_decls = 1565,
OPT_ggdb = 1566,
OPT_ggnu_pubnames = 1567,
OPT_gimple_stats = 1568,
OPT_ginline_points = 1569,
OPT_ginternal_reset_location_views = 1570,
OPT_gnat = 1571,
OPT_gnatO = 1572,
OPT_gno_ = 1573,
OPT_gno_pubnames = 1574,
OPT_gpubnames = 1575,
OPT_grecord_gcc_switches = 1576,
OPT_gsplit_dwarf = 1577,
OPT_gstabs = 1578,
OPT_gstabs_ = 1579,
OPT_gstatement_frontiers = 1580,
OPT_gstrict_dwarf = 1581,
OPT_gtoggle = 1582,
OPT_gvariable_location_views = 1583,
OPT_gvariable_location_views_incompat5 = 1584,
OPT_gvms = 1585,
OPT_gxcoff = 1586,
OPT_gxcoff_ = 1587,
OPT_gz = 1588,
OPT_gz_ = 1589,
OPT_h = 1590,
OPT_help = 1591,
OPT_idirafter = 1592,
OPT_imacros = 1593,
OPT_imultiarch = 1594,
OPT_imultilib = 1595,
OPT_include = 1596,
OPT_iplugindir_ = 1597,
OPT_iprefix = 1598,
OPT_iquote = 1599,
OPT_isysroot = 1600,
OPT_isystem = 1601,
OPT_iwithprefix = 1602,
OPT_iwithprefixbefore = 1603,
OPT_k8 = 1604,
OPT_l = 1605,
OPT_lang_asm = 1606,
OPT_list = 1607,
OPT_m128bit_long_double = 1608,
OPT_m16 = 1609,
OPT_m32 = 1610,
OPT_m3dnow = 1611,
OPT_m3dnowa = 1612,
OPT_m64 = 1613,
OPT_m80387 = 1614,
OPT_m8bit_idiv = 1615,
OPT_m96bit_long_double = 1616,
OPT_mabi_ = 1617,
OPT_mabm = 1618,
OPT_maccumulate_outgoing_args = 1619,
OPT_maddress_mode_ = 1620,
OPT_madx = 1621,
OPT_maes = 1622,
OPT_malign_data_ = 1623,
OPT_malign_double = 1624,
OPT_malign_functions_ = 1625,
OPT_malign_jumps_ = 1626,
OPT_malign_loops_ = 1627,
OPT_malign_stringops = 1628,
OPT_mandroid = 1629,
OPT_march_ = 1630,
OPT_masm_ = 1631,
OPT_mavx = 1632,
OPT_mavx2 = 1633,
OPT_mavx256_split_unaligned_load = 1634,
OPT_mavx256_split_unaligned_store = 1635,
OPT_mavx5124fmaps = 1636,
OPT_mavx5124vnniw = 1637,
OPT_mavx512bf16 = 1638,
OPT_mavx512bitalg = 1639,
OPT_mavx512bw = 1640,
OPT_mavx512cd = 1641,
OPT_mavx512dq = 1642,
OPT_mavx512er = 1643,
OPT_mavx512f = 1644,
OPT_mavx512ifma = 1645,
OPT_mavx512pf = 1646,
OPT_mavx512vbmi = 1647,
OPT_mavx512vbmi2 = 1648,
OPT_mavx512vl = 1649,
OPT_mavx512vnni = 1650,
OPT_mavx512vp2intersect = 1651,
OPT_mavx512vpopcntdq = 1652,
OPT_mbionic = 1653,
OPT_mbmi = 1654,
OPT_mbmi2 = 1655,
OPT_mbranch_cost_ = 1656,
OPT_mcall_ms2sysv_xlogues = 1657,
OPT_mcet_switch = 1658,
OPT_mcld = 1659,
OPT_mcldemote = 1660,
OPT_mclflushopt = 1661,
OPT_mclwb = 1662,
OPT_mclzero = 1663,
OPT_mcmodel_ = 1664,
OPT_mcrc32 = 1666,
OPT_mcx16 = 1667,
OPT_mdispatch_scheduler = 1668,
OPT_mdump_tune_features = 1669,
OPT_menqcmd = 1670,
OPT_mf16c = 1671,
OPT_mfancy_math_387 = 1672,
OPT_mfentry = 1673,
OPT_mfentry_name_ = 1674,
OPT_mfentry_section_ = 1675,
OPT_mfma = 1676,
OPT_mfma4 = 1677,
OPT_mforce_drap = 1678,
OPT_mforce_indirect_call = 1679,
OPT_mfp_ret_in_387 = 1680,
OPT_mfpmath_ = 1681,
OPT_mfsgsbase = 1682,
OPT_mfunction_return_ = 1683,
OPT_mfxsr = 1685,
OPT_mgeneral_regs_only = 1686,
OPT_mgfni = 1687,
OPT_mglibc = 1688,
OPT_mhard_float = 1689,
OPT_mhle = 1690,
OPT_miamcu = 1691,
OPT_mieee_fp = 1692,
OPT_mincoming_stack_boundary_ = 1693,
OPT_mindirect_branch_register = 1694,
OPT_mindirect_branch_ = 1695,
OPT_minline_all_stringops = 1696,
OPT_minline_stringops_dynamically = 1697,
OPT_minstrument_return_ = 1698,
OPT_mlarge_data_threshold_ = 1700,
OPT_mlong_double_128 = 1701,
OPT_mlong_double_64 = 1702,
OPT_mlong_double_80 = 1703,
OPT_mlwp = 1704,
OPT_mlzcnt = 1705,
OPT_mmanual_endbr = 1706,
OPT_mmemcpy_strategy_ = 1707,
OPT_mmemset_strategy_ = 1708,
OPT_mmitigate_rop = 1709,
OPT_mmmx = 1710,
OPT_mmovbe = 1711,
OPT_mmovdir64b = 1712,
OPT_mmovdiri = 1713,
OPT_mmpx = 1714,
OPT_mms_bitfields = 1715,
OPT_mmusl = 1716,
OPT_mmwaitx = 1717,
OPT_mno_align_stringops = 1718,
OPT_mno_default = 1719,
OPT_mno_fancy_math_387 = 1720,
OPT_mno_push_args = 1721,
OPT_mno_red_zone = 1722,
OPT_mno_sse4 = 1723,
OPT_mnop_mcount = 1724,
OPT_momit_leaf_frame_pointer = 1725,
OPT_mpc32 = 1726,
OPT_mpc64 = 1727,
OPT_mpc80 = 1728,
OPT_mpclmul = 1729,
OPT_mpcommit = 1730,
OPT_mpconfig = 1731,
OPT_mpku = 1732,
OPT_mpopcnt = 1733,
OPT_mprefer_vector_width_ = 1735,
OPT_mpreferred_stack_boundary_ = 1736,
OPT_mprefetchwt1 = 1737,
OPT_mprfchw = 1738,
OPT_mptwrite = 1739,
OPT_mpush_args = 1740,
OPT_mrdpid = 1741,
OPT_mrdrnd = 1742,
OPT_mrdseed = 1743,
OPT_mrecip = 1744,
OPT_mrecip_ = 1745,
OPT_mrecord_mcount = 1746,
OPT_mrecord_return = 1747,
OPT_mred_zone = 1748,
OPT_mregparm_ = 1749,
OPT_mrtd = 1750,
OPT_mrtm = 1751,
OPT_msahf = 1752,
OPT_mserialize = 1753,
OPT_msgx = 1754,
OPT_msha = 1755,
OPT_mshstk = 1756,
OPT_mskip_rax_setup = 1757,
OPT_msoft_float = 1758,
OPT_msse = 1759,
OPT_msse2 = 1760,
OPT_msse2avx = 1761,
OPT_msse3 = 1762,
OPT_msse4 = 1763,
OPT_msse4_1 = 1764,
OPT_msse4_2 = 1765,
OPT_msse4a = 1766,
OPT_msseregparm = 1768,
OPT_mssse3 = 1769,
OPT_mstack_arg_probe = 1770,
OPT_mstack_protector_guard_offset_ = 1771,
OPT_mstack_protector_guard_reg_ = 1772,
OPT_mstack_protector_guard_symbol_ = 1773,
OPT_mstack_protector_guard_ = 1774,
OPT_mstackrealign = 1775,
OPT_mstringop_strategy_ = 1776,
OPT_mstv = 1777,
OPT_mtbm = 1778,
OPT_mtls_dialect_ = 1779,
OPT_mtls_direct_seg_refs = 1780,
OPT_mtsxldtrk = 1781,
OPT_mtune_ctrl_ = 1782,
OPT_mtune_ = 1783,
OPT_muclibc = 1784,
OPT_mvaes = 1785,
OPT_mveclibabi_ = 1786,
OPT_mvect8_ret_in_mem = 1787,
OPT_mvpclmulqdq = 1788,
OPT_mvzeroupper = 1789,
OPT_mwaitpkg = 1790,
OPT_mwbnoinvd = 1791,
OPT_mx32 = 1792,
OPT_mxop = 1793,
OPT_mxsave = 1794,
OPT_mxsavec = 1795,
OPT_mxsaveopt = 1796,
OPT_mxsaves = 1797,
OPT_n = 1798,
OPT_name_sort = 1799,
OPT_no_canonical_prefixes = 1800,
OPT_no_integrated_cpp = 1801,
OPT_no_pie = 1802,
OPT_nocpp = 1803,
OPT_nodefaultlibs = 1804,
OPT_nolibc = 1805,
OPT_nophoboslib = 1806,
OPT_nostartfiles = 1807,
OPT_nostdinc = 1808,
OPT_nostdinc__ = 1809,
OPT_nostdlib = 1810,
OPT_o = 1811,
OPT_objects = 1812,
OPT_p = 1813,
OPT_pass_exit_codes = 1814,
OPT_pedantic_errors = 1816,
OPT_pg = 1817,
OPT_pie = 1818,
OPT_pipe = 1819,
OPT_posix = 1820,
OPT_print_file_name_ = 1821,
OPT_print_libgcc_file_name = 1822,
OPT_print_multi_directory = 1823,
OPT_print_multi_lib = 1824,
OPT_print_multi_os_directory = 1825,
OPT_print_multiarch = 1826,
OPT_print_objc_runtime_info = 1827,
OPT_print_prog_name_ = 1828,
OPT_print_search_dirs = 1829,
OPT_print_sysroot = 1830,
OPT_print_sysroot_headers_suffix = 1831,
OPT_print_value = 1832,
OPT_profile = 1833,
OPT_pthread = 1834,
OPT_quiet = 1835,
OPT_r = 1836,
OPT_rdynamic = 1837,
OPT_remap = 1838,
OPT_reverse_sort = 1839,
OPT_s = 1840,
OPT_save_temps = 1841,
OPT_save_temps_ = 1842,
OPT_shared = 1843,
OPT_shared_libgcc = 1844,
OPT_shared_libphobos = 1845,
OPT_size_sort = 1846,
OPT_specs_ = 1848,
OPT_static = 1849,
OPT_static_libasan = 1850,
OPT_static_libgcc = 1851,
OPT_static_libgfortran = 1852,
OPT_static_libgo = 1853,
OPT_static_liblsan = 1854,
OPT_static_libmpx = 1855,
OPT_static_libmpxwrappers = 1856,
OPT_static_libphobos = 1857,
OPT_static_libstdc__ = 1858,
OPT_static_libtsan = 1859,
OPT_static_libubsan = 1860,
OPT_static_pie = 1861,
OPT_std_c__11 = 1864,
OPT_std_c__14 = 1865,
OPT_std_c__17 = 1866,
OPT_std_c__20 = 1869,
OPT_std_c__98 = 1871,
OPT_std_c11 = 1872,
OPT_std_c17 = 1873,
OPT_std_c2x = 1876,
OPT_std_c90 = 1878,
OPT_std_c99 = 1879,
OPT_std_f2003 = 1881,
OPT_std_f2008 = 1882,
OPT_std_f2008ts = 1883,
OPT_std_f2018 = 1884,
OPT_std_f95 = 1885,
OPT_std_gnu = 1886,
OPT_std_gnu__11 = 1889,
OPT_std_gnu__14 = 1890,
OPT_std_gnu__17 = 1891,
OPT_std_gnu__20 = 1894,
OPT_std_gnu__98 = 1896,
OPT_std_gnu11 = 1897,
OPT_std_gnu17 = 1898,
OPT_std_gnu2x = 1901,
OPT_std_gnu90 = 1903,
OPT_std_gnu99 = 1904,
OPT_std_iso9899_199409 = 1907,
OPT_std_legacy = 1913,
OPT_symbol_ = 1914,
OPT_symbolic = 1915,
OPT_t = 1916,
OPT_time = 1917,
OPT_time_ = 1918,
OPT_tno_android_cc = 1919,
OPT_tno_android_ld = 1920,
OPT_traditional = 1921,
OPT_traditional_cpp = 1922,
OPT_tree_stats = 1923,
OPT_trigraphs = 1924,
OPT_type_stats = 1925,
OPT_u = 1926,
OPT_undef = 1927,
OPT_v = 1928,
OPT_version = 1929,
OPT_w = 1930,
OPT_wrapper = 1931,
OPT_x = 1932,
OPT_z = 1933,
N_OPTS,
OPT_SPECIAL_unknown,
OPT_SPECIAL_ignore,
OPT_SPECIAL_warn_removed,
OPT_SPECIAL_program_name,
OPT_SPECIAL_input_file
};
# 23 "./tm.h" 2
# 1 "./insn-constants.h" 1
# 113 "./insn-constants.h"
enum unspec {
UNSPEC_GOT = 0,
UNSPEC_GOTOFF = 1,
UNSPEC_GOTPCREL = 2,
UNSPEC_GOTTPOFF = 3,
UNSPEC_TPOFF = 4,
UNSPEC_NTPOFF = 5,
UNSPEC_DTPOFF = 6,
UNSPEC_GOTNTPOFF = 7,
UNSPEC_INDNTPOFF = 8,
UNSPEC_PLTOFF = 9,
UNSPEC_MACHOPIC_OFFSET = 10,
UNSPEC_PCREL = 11,
UNSPEC_SIZEOF = 12,
UNSPEC_STACK_ALLOC = 13,
UNSPEC_SET_GOT = 14,
UNSPEC_SET_RIP = 15,
UNSPEC_SET_GOT_OFFSET = 16,
UNSPEC_MEMORY_BLOCKAGE = 17,
UNSPEC_PROBE_STACK = 18,
UNSPEC_TP = 19,
UNSPEC_TLS_GD = 20,
UNSPEC_TLS_LD_BASE = 21,
UNSPEC_TLSDESC = 22,
UNSPEC_TLS_IE_SUN = 23,
UNSPEC_SCAS = 24,
UNSPEC_FNSTSW = 25,
UNSPEC_SAHF = 26,
UNSPEC_NOTRAP = 27,
UNSPEC_PARITY = 28,
UNSPEC_FSTCW = 29,
UNSPEC_REP = 30,
UNSPEC_LD_MPIC = 31,
UNSPEC_TRUNC_NOOP = 32,
UNSPEC_DIV_ALREADY_SPLIT = 33,
UNSPEC_PAUSE = 34,
UNSPEC_LEA_ADDR = 35,
UNSPEC_XBEGIN_ABORT = 36,
UNSPEC_STOS = 37,
UNSPEC_PEEPSIB = 38,
UNSPEC_INSN_FALSE_DEP = 39,
UNSPEC_SBB = 40,
UNSPEC_FIX_NOTRUNC = 41,
UNSPEC_MASKMOV = 42,
UNSPEC_MOVMSK = 43,
UNSPEC_RCP = 44,
UNSPEC_RSQRT = 45,
UNSPEC_PSADBW = 46,
UNSPEC_COPYSIGN = 47,
UNSPEC_XORSIGN = 48,
UNSPEC_IEEE_MIN = 49,
UNSPEC_IEEE_MAX = 50,
UNSPEC_SIN = 51,
UNSPEC_COS = 52,
UNSPEC_FPATAN = 53,
UNSPEC_FYL2X = 54,
UNSPEC_FYL2XP1 = 55,
UNSPEC_FRNDINT = 56,
UNSPEC_FIST = 57,
UNSPEC_F2XM1 = 58,
UNSPEC_TAN = 59,
UNSPEC_FXAM = 60,
UNSPEC_FRNDINT_ROUNDEVEN = 61,
UNSPEC_FRNDINT_FLOOR = 62,
UNSPEC_FRNDINT_CEIL = 63,
UNSPEC_FRNDINT_TRUNC = 64,
UNSPEC_FIST_FLOOR = 65,
UNSPEC_FIST_CEIL = 66,
UNSPEC_SINCOS_COS = 67,
UNSPEC_SINCOS_SIN = 68,
UNSPEC_XTRACT_FRACT = 69,
UNSPEC_XTRACT_EXP = 70,
UNSPEC_FSCALE_FRACT = 71,
UNSPEC_FSCALE_EXP = 72,
UNSPEC_FPREM_F = 73,
UNSPEC_FPREM_U = 74,
UNSPEC_FPREM1_F = 75,
UNSPEC_FPREM1_U = 76,
UNSPEC_C2_FLAG = 77,
UNSPEC_FXAM_MEM = 78,
UNSPEC_SP_SET = 79,
UNSPEC_SP_TEST = 80,
UNSPEC_ROUND = 81,
UNSPEC_CRC32 = 82,
UNSPEC_LZCNT = 83,
UNSPEC_TZCNT = 84,
UNSPEC_BEXTR = 85,
UNSPEC_PDEP = 86,
UNSPEC_PEXT = 87,
UNSPEC_INTERRUPT_RETURN = 88,
UNSPEC_MOVNTQ = 89,
UNSPEC_PFRCP = 90,
UNSPEC_PFRCPIT1 = 91,
UNSPEC_PFRCPIT2 = 92,
UNSPEC_PFRSQRT = 93,
UNSPEC_PFRSQIT1 = 94,
UNSPEC_MOVNT = 95,
UNSPEC_MOVDI_TO_SSE = 96,
UNSPEC_LDDQU = 97,
UNSPEC_PSHUFB = 98,
UNSPEC_PSIGN = 99,
UNSPEC_PALIGNR = 100,
UNSPEC_EXTRQI = 101,
UNSPEC_EXTRQ = 102,
UNSPEC_INSERTQI = 103,
UNSPEC_INSERTQ = 104,
UNSPEC_BLENDV = 105,
UNSPEC_INSERTPS = 106,
UNSPEC_DP = 107,
UNSPEC_MOVNTDQA = 108,
UNSPEC_MPSADBW = 109,
UNSPEC_PHMINPOSUW = 110,
UNSPEC_PTEST = 111,
UNSPEC_PCMPESTR = 112,
UNSPEC_PCMPISTR = 113,
UNSPEC_FMADDSUB = 114,
UNSPEC_XOP_UNSIGNED_CMP = 115,
UNSPEC_XOP_TRUEFALSE = 116,
UNSPEC_XOP_PERMUTE = 117,
UNSPEC_FRCZ = 118,
UNSPEC_AESENC = 119,
UNSPEC_AESENCLAST = 120,
UNSPEC_AESDEC = 121,
UNSPEC_AESDECLAST = 122,
UNSPEC_AESIMC = 123,
UNSPEC_AESKEYGENASSIST = 124,
UNSPEC_PCLMUL = 125,
UNSPEC_PCMP = 126,
UNSPEC_VPERMIL = 127,
UNSPEC_VPERMIL2 = 128,
UNSPEC_VPERMIL2F128 = 129,
UNSPEC_CAST = 130,
UNSPEC_VTESTP = 131,
UNSPEC_VCVTPH2PS = 132,
UNSPEC_VCVTPS2PH = 133,
UNSPEC_VPERMVAR = 134,
UNSPEC_VPERMTI = 135,
UNSPEC_GATHER = 136,
UNSPEC_VSIBADDR = 137,
UNSPEC_VPERMT2 = 138,
UNSPEC_UNSIGNED_FIX_NOTRUNC = 139,
UNSPEC_UNSIGNED_PCMP = 140,
UNSPEC_TESTM = 141,
UNSPEC_TESTNM = 142,
UNSPEC_SCATTER = 143,
UNSPEC_RCP14 = 144,
UNSPEC_RSQRT14 = 145,
UNSPEC_FIXUPIMM = 146,
UNSPEC_SCALEF = 147,
UNSPEC_VTERNLOG = 148,
UNSPEC_GETEXP = 149,
UNSPEC_GETMANT = 150,
UNSPEC_ALIGN = 151,
UNSPEC_CONFLICT = 152,
UNSPEC_COMPRESS = 153,
UNSPEC_COMPRESS_STORE = 154,
UNSPEC_EXPAND = 155,
UNSPEC_MASKED_EQ = 156,
UNSPEC_MASKED_GT = 157,
UNSPEC_MASKOP = 158,
UNSPEC_KORTEST = 159,
UNSPEC_KTEST = 160,
UNSPEC_EMBEDDED_ROUNDING = 161,
UNSPEC_GATHER_PREFETCH = 162,
UNSPEC_SCATTER_PREFETCH = 163,
UNSPEC_EXP2 = 164,
UNSPEC_RCP28 = 165,
UNSPEC_RSQRT28 = 166,
UNSPEC_SHA1MSG1 = 167,
UNSPEC_SHA1MSG2 = 168,
UNSPEC_SHA1NEXTE = 169,
UNSPEC_SHA1RNDS4 = 170,
UNSPEC_SHA256MSG1 = 171,
UNSPEC_SHA256MSG2 = 172,
UNSPEC_SHA256RNDS2 = 173,
UNSPEC_DBPSADBW = 174,
UNSPEC_PMADDUBSW512 = 175,
UNSPEC_PMADDWD512 = 176,
UNSPEC_PSHUFHW = 177,
UNSPEC_PSHUFLW = 178,
UNSPEC_CVTINT2MASK = 179,
UNSPEC_REDUCE = 180,
UNSPEC_FPCLASS = 181,
UNSPEC_RANGE = 182,
UNSPEC_VPMADD52LUQ = 183,
UNSPEC_VPMADD52HUQ = 184,
UNSPEC_VPMULTISHIFT = 185,
UNSPEC_VP4FMADD = 186,
UNSPEC_VP4FNMADD = 187,
UNSPEC_VP4DPWSSD = 188,
UNSPEC_VP4DPWSSDS = 189,
UNSPEC_GF2P8AFFINEINV = 190,
UNSPEC_GF2P8AFFINE = 191,
UNSPEC_GF2P8MUL = 192,
UNSPEC_VPSHLD = 193,
UNSPEC_VPSHRD = 194,
UNSPEC_VPSHRDV = 195,
UNSPEC_VPSHLDV = 196,
UNSPEC_VPMADDUBSWACCD = 197,
UNSPEC_VPMADDUBSWACCSSD = 198,
UNSPEC_VPMADDWDACCD = 199,
UNSPEC_VPMADDWDACCSSD = 200,
UNSPEC_VAESDEC = 201,
UNSPEC_VAESDECLAST = 202,
UNSPEC_VAESENC = 203,
UNSPEC_VAESENCLAST = 204,
UNSPEC_VPCLMULQDQ = 205,
UNSPEC_VPSHUFBIT = 206,
UNSPEC_VP2INTERSECT = 207,
UNSPEC_VCVTNE2PS2BF16 = 208,
UNSPEC_VCVTNEPS2BF16 = 209,
UNSPEC_VDPBF16PS = 210,
UNSPEC_LFENCE = 211,
UNSPEC_SFENCE = 212,
UNSPEC_MFENCE = 213,
UNSPEC_FILD_ATOMIC = 214,
UNSPEC_FIST_ATOMIC = 215,
UNSPEC_LDX_ATOMIC = 216,
UNSPEC_STX_ATOMIC = 217,
UNSPEC_LDA = 218,
UNSPEC_STA = 219
};
extern const char *const unspec_strings[];
enum unspecv {
UNSPECV_UD2 = 0,
UNSPECV_BLOCKAGE = 1,
UNSPECV_STACK_PROBE = 2,
UNSPECV_PROBE_STACK_RANGE = 3,
UNSPECV_ALIGN = 4,
UNSPECV_PROLOGUE_USE = 5,
UNSPECV_SPLIT_STACK_RETURN = 6,
UNSPECV_CLD = 7,
UNSPECV_NOPS = 8,
UNSPECV_RDTSC = 9,
UNSPECV_RDTSCP = 10,
UNSPECV_RDPMC = 11,
UNSPECV_LLWP_INTRINSIC = 12,
UNSPECV_SLWP_INTRINSIC = 13,
UNSPECV_LWPVAL_INTRINSIC = 14,
UNSPECV_LWPINS_INTRINSIC = 15,
UNSPECV_RDFSBASE = 16,
UNSPECV_RDGSBASE = 17,
UNSPECV_WRFSBASE = 18,
UNSPECV_WRGSBASE = 19,
UNSPECV_FXSAVE = 20,
UNSPECV_FXRSTOR = 21,
UNSPECV_FXSAVE64 = 22,
UNSPECV_FXRSTOR64 = 23,
UNSPECV_XSAVE = 24,
UNSPECV_XRSTOR = 25,
UNSPECV_XSAVE64 = 26,
UNSPECV_XRSTOR64 = 27,
UNSPECV_XSAVEOPT = 28,
UNSPECV_XSAVEOPT64 = 29,
UNSPECV_XSAVES = 30,
UNSPECV_XRSTORS = 31,
UNSPECV_XSAVES64 = 32,
UNSPECV_XRSTORS64 = 33,
UNSPECV_XSAVEC = 34,
UNSPECV_XSAVEC64 = 35,
UNSPECV_XGETBV = 36,
UNSPECV_XSETBV = 37,
UNSPECV_WBINVD = 38,
UNSPECV_WBNOINVD = 39,
UNSPECV_FNSTENV = 40,
UNSPECV_FLDENV = 41,
UNSPECV_FNSTSW = 42,
UNSPECV_FNCLEX = 43,
UNSPECV_RDRAND = 44,
UNSPECV_RDSEED = 45,
UNSPECV_XBEGIN = 46,
UNSPECV_XEND = 47,
UNSPECV_XABORT = 48,
UNSPECV_XTEST = 49,
UNSPECV_NLGR = 50,
UNSPECV_CLWB = 51,
UNSPECV_CLFLUSHOPT = 52,
UNSPECV_MONITORX = 53,
UNSPECV_MWAITX = 54,
UNSPECV_CLZERO = 55,
UNSPECV_PKU = 56,
UNSPECV_RDPID = 57,
UNSPECV_NOP_ENDBR = 58,
UNSPECV_NOP_RDSSP = 59,
UNSPECV_INCSSP = 60,
UNSPECV_SAVEPREVSSP = 61,
UNSPECV_RSTORSSP = 62,
UNSPECV_WRSS = 63,
UNSPECV_WRUSS = 64,
UNSPECV_SETSSBSY = 65,
UNSPECV_CLRSSBSY = 66,
UNSPECV_MOVDIRI = 67,
UNSPECV_MOVDIR64B = 68,
UNSPECV_XSUSLDTRK = 69,
UNSPECV_XRESLDTRK = 70,
UNSPECV_UMWAIT = 71,
UNSPECV_UMONITOR = 72,
UNSPECV_TPAUSE = 73,
UNSPECV_CLDEMOTE = 74,
UNSPECV_SPECULATION_BARRIER = 75,
UNSPECV_PTWRITE = 76,
UNSPECV_ENQCMD = 77,
UNSPECV_ENQCMDS = 78,
UNSPECV_SERIALIZE = 79,
UNSPECV_PATCHABLE_AREA = 80,
UNSPECV_EMMS = 81,
UNSPECV_FEMMS = 82,
UNSPECV_LDMXCSR = 83,
UNSPECV_STMXCSR = 84,
UNSPECV_CLFLUSH = 85,
UNSPECV_MONITOR = 86,
UNSPECV_MWAIT = 87,
UNSPECV_VZEROALL = 88,
UNSPECV_VZEROUPPER = 89,
UNSPECV_CMPXCHG = 90,
UNSPECV_XCHG = 91,
UNSPECV_LOCK = 92
};
extern const char *const unspecv_strings[];
# 24 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/vxworks-dummy.h" 1
# 25 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/biarch64.h" 1
# 26 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h" 1
# 216 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/vxworks-dummy.h" 1
# 217 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h" 2
# 234 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
struct stringop_algs
{
const enum stringop_alg unknown_size;
const struct stringop_strategy {
const int max;
const enum stringop_alg alg;
int noalign;
} size [4];
};
# 252 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
struct processor_costs {
struct
{
const int movzbl_load;
const int int_load[3];
const int int_store[3];
const int fp_move;
const int fp_load[3];
const int fp_store[3];
const int mmx_move;
const int mmx_load[2];
const int mmx_store[2];
const int xmm_move;
const int ymm_move;
const int zmm_move;
const int sse_load[5];
const int sse_store[5];
const int sse_to_integer;
const int integer_to_sse;
} hard_register;
const int add;
const int lea;
const int shift_var;
const int shift_const;
const int mult_init[5];
const int mult_bit;
const int divide[5];
int movsx;
int movzx;
const int large_insn;
const int move_ratio;
const int clear_ratio;
const int int_load[3];
const int int_store[3];
const int sse_load[5];
const int sse_store[5];
const int sse_unaligned_load[5];
const int sse_unaligned_store[5];
const int xmm_move, ymm_move,
zmm_move;
const int sse_to_integer;
const int gather_static, gather_per_elt;
const int scatter_static, scatter_per_elt;
const int l1_cache_size;
const int l2_cache_size;
const int prefetch_block;
const int simultaneous_prefetches;
const int branch_cost;
const int fadd;
const int fmul;
const int fdiv;
const int fabs;
const int fchs;
const int fsqrt;
const int sse_op;
const int addss;
const int mulss;
const int mulsd;
const int fmass;
const int fmasd;
const int divss;
const int divsd;
const int sqrtss;
const int sqrtsd;
const int reassoc_int, reassoc_fp, reassoc_vec_int, reassoc_vec_fp;
struct stringop_algs *memcpy, *memset;
const int cond_taken_branch_cost;
const int cond_not_taken_branch_cost;
const char *const align_loop;
const char *const align_jump;
const char *const align_label;
const char *const align_func;
};
extern const struct processor_costs *ix86_cost;
extern const struct processor_costs ix86_size_cost;
# 466 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
enum ix86_tune_indices {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def" 1
# 42 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_SCHEDULE,
# 51 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_PARTIAL_REG_DEPENDENCY,
# 63 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY,
X86_TUNE_SSE_SPLIT_REGS,
# 82 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_PARTIAL_FLAG_REG_STALL,
X86_TUNE_MOVX,
X86_TUNE_MEMORY_MISMATCH_STALL,
X86_TUNE_FUSE_CMP_AND_BRANCH_32,
X86_TUNE_FUSE_CMP_AND_BRANCH_64,
X86_TUNE_FUSE_CMP_AND_BRANCH_SOFLAGS,
X86_TUNE_FUSE_ALU_AND_BRANCH,
# 137 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_ACCUMULATE_OUTGOING_ARGS,
X86_TUNE_PROLOGUE_USING_MOVE,
X86_TUNE_EPILOGUE_USING_MOVE,
X86_TUNE_USE_LEAVE,
X86_TUNE_PUSH_MEMORY,
X86_TUNE_SINGLE_PUSH,
X86_TUNE_DOUBLE_PUSH,
X86_TUNE_SINGLE_POP,
X86_TUNE_DOUBLE_POP,
X86_TUNE_PAD_SHORT_FUNCTION,
X86_TUNE_PAD_RETURNS,
X86_TUNE_FOUR_JUMP_LIMIT,
# 211 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_SOFTWARE_PREFETCHING_BENEFICIAL,
X86_TUNE_LCP_STALL,
X86_TUNE_READ_MODIFY,
X86_TUNE_USE_INCDEC,
X86_TUNE_INTEGER_DFMODE_MOVES,
X86_TUNE_OPT_AGU,
X86_TUNE_AVOID_LEA_FOR_ADDR,
X86_TUNE_SLOW_IMUL_IMM32_MEM,
X86_TUNE_SLOW_IMUL_IMM8,
X86_TUNE_AVOID_MEM_OPND_FOR_CMOVE,
X86_TUNE_SINGLE_STRINGOP,
X86_TUNE_MISALIGNED_MOVE_STRING_PRO_EPILOGUES,
X86_TUNE_USE_SAHF,
X86_TUNE_USE_CLTD,
X86_TUNE_USE_BT,
X86_TUNE_AVOID_FALSE_DEP_FOR_BMI,
X86_TUNE_ADJUST_UNROLL,
X86_TUNE_ONE_IF_CONV_INSN,
X86_TUNE_AVOID_MFENCE,
X86_TUNE_EXPAND_ABS,
# 334 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_USE_HIMODE_FIOP,
X86_TUNE_USE_SIMODE_FIOP,
X86_TUNE_USE_FFREEP,
X86_TUNE_EXT_80387_CONSTANTS,
# 359 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_GENERAL_REGS_SSE_SPILL,
X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL,
X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL,
X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL,
X86_TUNE_SSE_TYPELESS_STORES,
X86_TUNE_SSE_LOAD0_BY_PXOR,
# 398 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_INTER_UNIT_MOVES_TO_VEC,
X86_TUNE_INTER_UNIT_MOVES_FROM_VEC,
X86_TUNE_INTER_UNIT_CONVERSIONS,
X86_TUNE_SPLIT_MEM_OPND_FOR_FP_CONVERTS,
X86_TUNE_USE_VECTOR_FP_CONVERTS,
X86_TUNE_USE_VECTOR_CONVERTS,
X86_TUNE_SLOW_PSHUFB,
X86_TUNE_AVOID_4BYTE_PREFIXES,
X86_TUNE_USE_GATHER,
X86_TUNE_AVOID_128FMA_CHAINS,
X86_TUNE_AVOID_256FMA_CHAINS,
X86_TUNE_AVX256_UNALIGNED_LOAD_OPTIMAL,
X86_TUNE_AVX256_UNALIGNED_STORE_OPTIMAL,
X86_TUNE_AVX256_SPLIT_REGS,
X86_TUNE_AVX128_OPTIMAL,
X86_TUNE_AVX256_OPTIMAL,
X86_TUNE_DOUBLE_WITH_ADD,
X86_TUNE_ALWAYS_FANCY_MATH_387,
X86_TUNE_UNROLL_STRLEN,
X86_TUNE_SHIFT1,
X86_TUNE_ZERO_EXTEND_WITH_AND,
X86_TUNE_PROMOTE_HIMODE_IMUL,
X86_TUNE_FAST_PREFIX,
X86_TUNE_READ_MODIFY_WRITE,
X86_TUNE_MOVE_M1_VIA_OR,
X86_TUNE_NOT_UNPAIRABLE,
# 539 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_PARTIAL_REG_STALL,
X86_TUNE_PROMOTE_QIMODE,
X86_TUNE_PROMOTE_HI_REGS,
X86_TUNE_HIMODE_MATH,
X86_TUNE_SPLIT_LONG_MOVES,
X86_TUNE_USE_XCHGB,
X86_TUNE_USE_MOV0,
X86_TUNE_NOT_VECTORMODE,
X86_TUNE_AVOID_VECTOR_DECODE,
# 583 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-tune.def"
X86_TUNE_BRANCH_PREDICTION_HINTS,
X86_TUNE_QIMODE_MATH,
X86_TUNE_PROMOTE_QI_REGS,
X86_TUNE_EMIT_VZEROUPPER,
# 470 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h" 2
X86_TUNE_LAST
};
extern unsigned char ix86_tune_features[X86_TUNE_LAST];
# 608 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
enum ix86_arch_indices {
X86_ARCH_CMOV,
X86_ARCH_CMPXCHG,
X86_ARCH_CMPXCHG8B,
X86_ARCH_XADD,
X86_ARCH_BSWAP,
X86_ARCH_LAST
};
extern unsigned char ix86_arch_features[X86_ARCH_LAST];
# 633 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
extern unsigned char x86_prefetch_sse;
# 663 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
extern tree x86_mfence;
# 729 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
extern const char *host_detect_local_cpu (int argc, const char **argv);
# 1388 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
enum reg_class
{
NO_REGS,
AREG, DREG, CREG, BREG, SIREG, DIREG,
AD_REGS,
CLOBBERED_REGS,
Q_REGS,
NON_Q_REGS,
TLS_GOTBASE_REGS,
INDEX_REGS,
LEGACY_REGS,
GENERAL_REGS,
FP_TOP_REG, FP_SECOND_REG,
FLOAT_REGS,
SSE_FIRST_REG,
NO_REX_SSE_REGS,
SSE_REGS,
ALL_SSE_REGS,
MMX_REGS,
FLOAT_SSE_REGS,
FLOAT_INT_REGS,
INT_SSE_REGS,
FLOAT_INT_SSE_REGS,
MASK_REGS,
ALL_MASK_REGS,
ALL_REGS,
LIM_REG_CLASSES
};
# 1692 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
typedef struct ix86_args {
int words;
int nregs;
int regno;
int fastcall;
int sse_words;
int sse_nregs;
int warn_avx512f;
int warn_avx;
int warn_sse;
int warn_mmx;
int warn_empty;
int sse_regno;
int mmx_words;
int mmx_nregs;
int mmx_regno;
int maybe_vaarg;
int caller;
int float_in_sse;
int stdarg;
enum calling_abi call_abi;
tree decl;
} CUMULATIVE_ARGS;
# 2151 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
extern int const dbx_register_map[76];
extern int const dbx64_register_map[76];
extern int const svr4_dbx_register_map[76];
# 2323 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
enum processor_type
{
PROCESSOR_GENERIC = 0,
PROCESSOR_I386,
PROCESSOR_I486,
PROCESSOR_PENTIUM,
PROCESSOR_LAKEMONT,
PROCESSOR_PENTIUMPRO,
PROCESSOR_PENTIUM4,
PROCESSOR_NOCONA,
PROCESSOR_CORE2,
PROCESSOR_NEHALEM,
PROCESSOR_SANDYBRIDGE,
PROCESSOR_HASWELL,
PROCESSOR_BONNELL,
PROCESSOR_SILVERMONT,
PROCESSOR_GOLDMONT,
PROCESSOR_GOLDMONT_PLUS,
PROCESSOR_TREMONT,
PROCESSOR_KNL,
PROCESSOR_KNM,
PROCESSOR_SKYLAKE,
PROCESSOR_SKYLAKE_AVX512,
PROCESSOR_CANNONLAKE,
PROCESSOR_ICELAKE_CLIENT,
PROCESSOR_ICELAKE_SERVER,
PROCESSOR_CASCADELAKE,
PROCESSOR_TIGERLAKE,
PROCESSOR_COOPERLAKE,
PROCESSOR_SAPPHIRERAPIDS,
PROCESSOR_ALDERLAKE,
PROCESSOR_INTEL,
PROCESSOR_GEODE,
PROCESSOR_K6,
PROCESSOR_ATHLON,
PROCESSOR_K8,
PROCESSOR_AMDFAM10,
PROCESSOR_BDVER1,
PROCESSOR_BDVER2,
PROCESSOR_BDVER3,
PROCESSOR_BDVER4,
PROCESSOR_BTVER1,
PROCESSOR_BTVER2,
PROCESSOR_ZNVER1,
PROCESSOR_ZNVER2,
PROCESSOR_max
};
extern const char *const processor_names[];
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int-bitmask.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/wide-int-bitmask.h"
class wide_int_bitmask
{
public:
inline wide_int_bitmask ();
inline wide_int_bitmask (uint64_t l);
inline wide_int_bitmask (uint64_t l, uint64_t h);
inline wide_int_bitmask &operator &= (wide_int_bitmask);
inline wide_int_bitmask &operator |= (wide_int_bitmask);
inline wide_int_bitmask operator ~ () const;
inline wide_int_bitmask operator & (wide_int_bitmask) const;
inline wide_int_bitmask operator | (wide_int_bitmask) const;
inline wide_int_bitmask operator >> (int);
inline wide_int_bitmask operator << (int);
inline bool operator == (wide_int_bitmask) const;
inline bool operator != (wide_int_bitmask) const;
uint64_t low, high;
};
inline
wide_int_bitmask::wide_int_bitmask ()
: low (0), high (0)
{
}
inline
wide_int_bitmask::wide_int_bitmask (uint64_t l)
: low (l), high (0)
{
}
inline
wide_int_bitmask::wide_int_bitmask (uint64_t l, uint64_t h)
: low (l), high (h)
{
}
inline wide_int_bitmask &
wide_int_bitmask::operator &= (wide_int_bitmask b)
{
low &= b.low;
high &= b.high;
return *this;
}
inline wide_int_bitmask &
wide_int_bitmask::operator |= (wide_int_bitmask b)
{
low |= b.low;
high |= b.high;
return *this;
}
inline wide_int_bitmask
wide_int_bitmask::operator ~ () const
{
wide_int_bitmask ret (~low, ~high);
return ret;
}
inline wide_int_bitmask
wide_int_bitmask::operator | (wide_int_bitmask b) const
{
wide_int_bitmask ret (low | b.low, high | b.high);
return ret;
}
inline wide_int_bitmask
wide_int_bitmask::operator & (wide_int_bitmask b) const
{
wide_int_bitmask ret (low & b.low, high & b.high);
return ret;
}
inline wide_int_bitmask
wide_int_bitmask::operator << (int amount)
{
wide_int_bitmask ret;
if (amount >= 64)
{
ret.low = 0;
ret.high = low << (amount - 64);
}
else if (amount == 0)
ret = *this;
else
{
ret.low = low << amount;
ret.high = (low >> (64 - amount)) | (high << amount);
}
return ret;
}
inline wide_int_bitmask
wide_int_bitmask::operator >> (int amount)
{
wide_int_bitmask ret;
if (amount >= 64)
{
ret.low = high >> (amount - 64);
ret.high = 0;
}
else if (amount == 0)
ret = *this;
else
{
ret.low = (high << (64 - amount)) | (low >> amount);
ret.high = high >> amount;
}
return ret;
}
inline bool
wide_int_bitmask::operator == (wide_int_bitmask b) const
{
return low == b.low && high == b.high;
}
inline bool
wide_int_bitmask::operator != (wide_int_bitmask b) const
{
return low != b.low || high != b.high;
}
# 2375 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h" 2
const wide_int_bitmask PTA_3DNOW (1UL << 0);
const wide_int_bitmask PTA_3DNOW_A (1UL << 1);
const wide_int_bitmask PTA_64BIT (1UL << 2);
const wide_int_bitmask PTA_ABM (1UL << 3);
const wide_int_bitmask PTA_AES (1UL << 4);
const wide_int_bitmask PTA_AVX (1UL << 5);
const wide_int_bitmask PTA_BMI (1UL << 6);
const wide_int_bitmask PTA_CX16 (1UL << 7);
const wide_int_bitmask PTA_F16C (1UL << 8);
const wide_int_bitmask PTA_FMA (1UL << 9);
const wide_int_bitmask PTA_FMA4 (1UL << 10);
const wide_int_bitmask PTA_FSGSBASE (1UL << 11);
const wide_int_bitmask PTA_LWP (1UL << 12);
const wide_int_bitmask PTA_LZCNT (1UL << 13);
const wide_int_bitmask PTA_MMX (1UL << 14);
const wide_int_bitmask PTA_MOVBE (1UL << 15);
const wide_int_bitmask PTA_NO_SAHF (1UL << 16);
const wide_int_bitmask PTA_PCLMUL (1UL << 17);
const wide_int_bitmask PTA_POPCNT (1UL << 18);
const wide_int_bitmask PTA_PREFETCH_SSE (1UL << 19);
const wide_int_bitmask PTA_RDRND (1UL << 20);
const wide_int_bitmask PTA_SSE (1UL << 21);
const wide_int_bitmask PTA_SSE2 (1UL << 22);
const wide_int_bitmask PTA_SSE3 (1UL << 23);
const wide_int_bitmask PTA_SSE4_1 (1UL << 24);
const wide_int_bitmask PTA_SSE4_2 (1UL << 25);
const wide_int_bitmask PTA_SSE4A (1UL << 26);
const wide_int_bitmask PTA_SSSE3 (1UL << 27);
const wide_int_bitmask PTA_TBM (1UL << 28);
const wide_int_bitmask PTA_XOP (1UL << 29);
const wide_int_bitmask PTA_AVX2 (1UL << 30);
const wide_int_bitmask PTA_BMI2 (1UL << 31);
const wide_int_bitmask PTA_RTM (1UL << 32);
const wide_int_bitmask PTA_HLE (1UL << 33);
const wide_int_bitmask PTA_PRFCHW (1UL << 34);
const wide_int_bitmask PTA_RDSEED (1UL << 35);
const wide_int_bitmask PTA_ADX (1UL << 36);
const wide_int_bitmask PTA_FXSR (1UL << 37);
const wide_int_bitmask PTA_XSAVE (1UL << 38);
const wide_int_bitmask PTA_XSAVEOPT (1UL << 39);
const wide_int_bitmask PTA_AVX512F (1UL << 40);
const wide_int_bitmask PTA_AVX512ER (1UL << 41);
const wide_int_bitmask PTA_AVX512PF (1UL << 42);
const wide_int_bitmask PTA_AVX512CD (1UL << 43);
const wide_int_bitmask PTA_SHA (1UL << 45);
const wide_int_bitmask PTA_PREFETCHWT1 (1UL << 46);
const wide_int_bitmask PTA_CLFLUSHOPT (1UL << 47);
const wide_int_bitmask PTA_XSAVEC (1UL << 48);
const wide_int_bitmask PTA_XSAVES (1UL << 49);
const wide_int_bitmask PTA_AVX512DQ (1UL << 50);
const wide_int_bitmask PTA_AVX512BW (1UL << 51);
const wide_int_bitmask PTA_AVX512VL (1UL << 52);
const wide_int_bitmask PTA_AVX512IFMA (1UL << 53);
const wide_int_bitmask PTA_AVX512VBMI (1UL << 54);
const wide_int_bitmask PTA_CLWB (1UL << 55);
const wide_int_bitmask PTA_MWAITX (1UL << 56);
const wide_int_bitmask PTA_CLZERO (1UL << 57);
const wide_int_bitmask PTA_NO_80387 (1UL << 58);
const wide_int_bitmask PTA_PKU (1UL << 59);
const wide_int_bitmask PTA_AVX5124VNNIW (1UL << 60);
const wide_int_bitmask PTA_AVX5124FMAPS (1UL << 61);
const wide_int_bitmask PTA_AVX512VPOPCNTDQ (1UL << 62);
const wide_int_bitmask PTA_SGX (1UL << 63);
const wide_int_bitmask PTA_AVX512VNNI (0, 1UL);
const wide_int_bitmask PTA_GFNI (0, 1UL << 1);
const wide_int_bitmask PTA_VAES (0, 1UL << 2);
const wide_int_bitmask PTA_AVX512VBMI2 (0, 1UL << 3);
const wide_int_bitmask PTA_VPCLMULQDQ (0, 1UL << 4);
const wide_int_bitmask PTA_AVX512BITALG (0, 1UL << 5);
const wide_int_bitmask PTA_RDPID (0, 1UL << 6);
const wide_int_bitmask PTA_PCONFIG (0, 1UL << 7);
const wide_int_bitmask PTA_WBNOINVD (0, 1UL << 8);
const wide_int_bitmask PTA_AVX512VP2INTERSECT (0, 1UL << 9);
const wide_int_bitmask PTA_PTWRITE (0, 1UL << 10);
const wide_int_bitmask PTA_AVX512BF16 (0, 1UL << 11);
const wide_int_bitmask PTA_WAITPKG (0, 1UL << 12);
const wide_int_bitmask PTA_MOVDIRI(0, 1UL << 13);
const wide_int_bitmask PTA_MOVDIR64B(0, 1UL << 14);
const wide_int_bitmask PTA_ENQCMD (0, 1UL << 15);
const wide_int_bitmask PTA_CLDEMOTE (0, 1UL << 16);
const wide_int_bitmask PTA_SERIALIZE (0, 1UL << 17);
const wide_int_bitmask PTA_TSXLDTRK (0, 1UL << 18);
const wide_int_bitmask PTA_CORE2 = PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2
| PTA_SSE3 | PTA_SSSE3 | PTA_CX16 | PTA_FXSR;
const wide_int_bitmask PTA_NEHALEM = PTA_CORE2 | PTA_SSE4_1 | PTA_SSE4_2
| PTA_POPCNT;
const wide_int_bitmask PTA_WESTMERE = PTA_NEHALEM | PTA_PCLMUL;
const wide_int_bitmask PTA_SANDYBRIDGE = PTA_WESTMERE | PTA_AVX | PTA_XSAVE
| PTA_XSAVEOPT;
const wide_int_bitmask PTA_IVYBRIDGE = PTA_SANDYBRIDGE | PTA_FSGSBASE
| PTA_RDRND | PTA_F16C;
const wide_int_bitmask PTA_HASWELL = PTA_IVYBRIDGE | PTA_AVX2 | PTA_BMI
| PTA_BMI2 | PTA_LZCNT | PTA_FMA | PTA_MOVBE | PTA_HLE;
const wide_int_bitmask PTA_BROADWELL = PTA_HASWELL | PTA_ADX | PTA_PRFCHW
| PTA_RDSEED;
const wide_int_bitmask PTA_SKYLAKE = PTA_BROADWELL | PTA_AES | PTA_CLFLUSHOPT
| PTA_XSAVEC | PTA_XSAVES | PTA_SGX;
const wide_int_bitmask PTA_SKYLAKE_AVX512 = PTA_SKYLAKE | PTA_AVX512F
| PTA_AVX512CD | PTA_AVX512VL | PTA_AVX512BW | PTA_AVX512DQ | PTA_PKU
| PTA_CLWB;
const wide_int_bitmask PTA_CASCADELAKE = PTA_SKYLAKE_AVX512 | PTA_AVX512VNNI;
const wide_int_bitmask PTA_COOPERLAKE = PTA_CASCADELAKE | PTA_AVX512BF16;
const wide_int_bitmask PTA_CANNONLAKE = PTA_SKYLAKE | PTA_AVX512F
| PTA_AVX512CD | PTA_AVX512VL | PTA_AVX512BW | PTA_AVX512DQ | PTA_PKU
| PTA_AVX512VBMI | PTA_AVX512IFMA | PTA_SHA;
const wide_int_bitmask PTA_ICELAKE_CLIENT = PTA_CANNONLAKE | PTA_AVX512VNNI
| PTA_GFNI | PTA_VAES | PTA_AVX512VBMI2 | PTA_VPCLMULQDQ | PTA_AVX512BITALG
| PTA_RDPID | PTA_AVX512VPOPCNTDQ;
const wide_int_bitmask PTA_ICELAKE_SERVER = PTA_ICELAKE_CLIENT | PTA_PCONFIG
| PTA_WBNOINVD | PTA_CLWB;
const wide_int_bitmask PTA_TIGERLAKE = PTA_ICELAKE_CLIENT | PTA_MOVDIRI
| PTA_MOVDIR64B | PTA_CLWB | PTA_AVX512VP2INTERSECT;
const wide_int_bitmask PTA_SAPPHIRERAPIDS = PTA_COOPERLAKE | PTA_MOVDIRI
| PTA_MOVDIR64B | PTA_AVX512VP2INTERSECT | PTA_ENQCMD | PTA_CLDEMOTE
| PTA_PTWRITE | PTA_WAITPKG | PTA_SERIALIZE | PTA_TSXLDTRK;
const wide_int_bitmask PTA_ALDERLAKE = PTA_SKYLAKE | PTA_CLDEMOTE | PTA_PTWRITE
| PTA_WAITPKG | PTA_SERIALIZE;
const wide_int_bitmask PTA_KNL = PTA_BROADWELL | PTA_AVX512PF | PTA_AVX512ER
| PTA_AVX512F | PTA_AVX512CD;
const wide_int_bitmask PTA_BONNELL = PTA_CORE2 | PTA_MOVBE;
const wide_int_bitmask PTA_SILVERMONT = PTA_WESTMERE | PTA_MOVBE | PTA_RDRND;
const wide_int_bitmask PTA_GOLDMONT = PTA_SILVERMONT | PTA_AES | PTA_SHA | PTA_XSAVE
| PTA_RDSEED | PTA_XSAVEC | PTA_XSAVES | PTA_CLFLUSHOPT | PTA_XSAVEOPT
| PTA_FSGSBASE;
const wide_int_bitmask PTA_GOLDMONT_PLUS = PTA_GOLDMONT | PTA_RDPID
| PTA_SGX | PTA_PTWRITE;
const wide_int_bitmask PTA_TREMONT = PTA_GOLDMONT_PLUS | PTA_CLWB
| PTA_GFNI;
const wide_int_bitmask PTA_KNM = PTA_KNL | PTA_AVX5124VNNIW
| PTA_AVX5124FMAPS | PTA_AVX512VPOPCNTDQ;
# 1 "./insn-attr-common.h" 1
enum attr_cpu {CPU_NONE, CPU_PENTIUM, CPU_PENTIUMPRO, CPU_GEODE, CPU_K6, CPU_ATHLON, CPU_K8, CPU_CORE2, CPU_NEHALEM, CPU_ATOM, CPU_SLM, CPU_GLM, CPU_HASWELL, CPU_GENERIC, CPU_AMDFAM10, CPU_BDVER1, CPU_BDVER2, CPU_BDVER3, CPU_BDVER4, CPU_BTVER2, CPU_ZNVER1, CPU_ZNVER2};
enum attr_type {TYPE_OTHER, TYPE_MULTI, TYPE_ALU, TYPE_ALU1, TYPE_NEGNOT, TYPE_IMOV, TYPE_IMOVX, TYPE_LEA, TYPE_INCDEC, TYPE_ISHIFT, TYPE_ISHIFTX, TYPE_ISHIFT1, TYPE_ROTATE, TYPE_ROTATEX, TYPE_ROTATE1, TYPE_IMUL, TYPE_IMULX, TYPE_IDIV, TYPE_ICMP, TYPE_TEST, TYPE_IBR, TYPE_SETCC, TYPE_ICMOV, TYPE_PUSH, TYPE_POP, TYPE_CALL, TYPE_CALLV, TYPE_LEAVE, TYPE_STR, TYPE_BITMANIP, TYPE_FMOV, TYPE_FOP, TYPE_FSGN, TYPE_FMUL, TYPE_FDIV, TYPE_FPSPC, TYPE_FCMOV, TYPE_FCMP, TYPE_FXCH, TYPE_FISTP, TYPE_FISTTP, TYPE_FRNDINT, TYPE_SSE, TYPE_SSEMOV, TYPE_SSEADD, TYPE_SSEADD1, TYPE_SSEIADD, TYPE_SSEIADD1, TYPE_SSEMUL, TYPE_SSEIMUL, TYPE_SSEDIV, TYPE_SSELOG, TYPE_SSELOG1, TYPE_SSEISHFT, TYPE_SSEISHFT1, TYPE_SSECMP, TYPE_SSECOMI, TYPE_SSECVT, TYPE_SSECVT1, TYPE_SSEICVT, TYPE_SSEINS, TYPE_SSESHUF, TYPE_SSESHUF1, TYPE_SSEMULADD, TYPE_SSE4ARG, TYPE_LWP, TYPE_MSKMOV, TYPE_MSKLOG, TYPE_MMX, TYPE_MMXMOV, TYPE_MMXADD, TYPE_MMXMUL, TYPE_MMXCMP, TYPE_MMXCVT, TYPE_MMXSHFT};
enum attr_mode {MODE_UNKNOWN, MODE_NONE, MODE_QI, MODE_HI, MODE_SI, MODE_DI, MODE_TI, MODE_OI, MODE_XI, MODE_SF, MODE_DF, MODE_XF, MODE_TF, MODE_V16SF, MODE_V8SF, MODE_V4DF, MODE_V4SF, MODE_V2DF, MODE_V2SF, MODE_V1DF, MODE_V8DF};
enum attr_unit {UNIT_INTEGER, UNIT_I387, UNIT_SSE, UNIT_MMX, UNIT_UNKNOWN};
enum attr_prefix {PREFIX_ORIG, PREFIX_VEX, PREFIX_MAYBE_VEX, PREFIX_EVEX, PREFIX_MAYBE_EVEX};
enum attr_memory {MEMORY_NONE, MEMORY_LOAD, MEMORY_STORE, MEMORY_BOTH, MEMORY_UNKNOWN};
enum attr_imm_disp {IMM_DISP_FALSE, IMM_DISP_TRUE, IMM_DISP_UNKNOWN};
enum attr_fp_int_src {FP_INT_SRC_FALSE, FP_INT_SRC_TRUE};
enum attr_i387_cw {I387_CW_ROUNDEVEN, I387_CW_FLOOR, I387_CW_CEIL, I387_CW_TRUNC, I387_CW_UNINITIALIZED, I387_CW_ANY};
enum attr_avx_partial_xmm_update {AVX_PARTIAL_XMM_UPDATE_FALSE, AVX_PARTIAL_XMM_UPDATE_TRUE};
enum attr_use_carry {USE_CARRY_0, USE_CARRY_1};
enum attr_movu {MOVU_0, MOVU_1};
enum attr_isa {ISA_BASE, ISA_X64, ISA_X64_SSE2, ISA_X64_SSE4, ISA_X64_SSE4_NOAVX, ISA_X64_AVX, ISA_NOX64, ISA_SSE_NOAVX, ISA_SSE2, ISA_SSE2_NOAVX, ISA_SSE3, ISA_SSE3_NOAVX, ISA_SSE4, ISA_SSE4_NOAVX, ISA_AVX, ISA_NOAVX, ISA_AVX2, ISA_NOAVX2, ISA_BMI, ISA_BMI2, ISA_FMA4, ISA_FMA, ISA_AVX512F, ISA_NOAVX512F, ISA_AVX512BW, ISA_NOAVX512BW, ISA_AVX512DQ, ISA_NOAVX512DQ, ISA_AVX512VL, ISA_NOAVX512VL, ISA_X64_AVX512DQ, ISA_X64_AVX512BW};
enum attr_mmx_isa {MMX_ISA_BASE, MMX_ISA_NATIVE, MMX_ISA_SSE, MMX_ISA_SSE_NOAVX, MMX_ISA_AVX};
enum attr_pent_prefix {PENT_PREFIX_FALSE, PENT_PREFIX_TRUE};
enum attr_pent_pair {PENT_PAIR_UV, PENT_PAIR_PU, PENT_PAIR_PV, PENT_PAIR_NP};
enum attr_athlon_decode {ATHLON_DECODE_DIRECT, ATHLON_DECODE_VECTOR, ATHLON_DECODE_DOUBLE};
enum attr_amdfam10_decode {AMDFAM10_DECODE_DIRECT, AMDFAM10_DECODE_VECTOR, AMDFAM10_DECODE_DOUBLE};
enum attr_bdver1_decode {BDVER1_DECODE_DIRECT, BDVER1_DECODE_VECTOR, BDVER1_DECODE_DOUBLE};
enum attr_btver2_decode {BTVER2_DECODE_DIRECT, BTVER2_DECODE_VECTOR, BTVER2_DECODE_DOUBLE};
enum attr_btver2_sse_attr {BTVER2_SSE_ATTR_OTHER, BTVER2_SSE_ATTR_RCP, BTVER2_SSE_ATTR_SQRT, BTVER2_SSE_ATTR_MAXMIN};
enum attr_znver1_decode {ZNVER1_DECODE_DIRECT, ZNVER1_DECODE_VECTOR, ZNVER1_DECODE_DOUBLE};
enum attr_atom_unit {ATOM_UNIT_SISHUF, ATOM_UNIT_SIMUL, ATOM_UNIT_JEU, ATOM_UNIT_COMPLEX, ATOM_UNIT_OTHER};
enum attr_atom_sse_attr {ATOM_SSE_ATTR_RCP, ATOM_SSE_ATTR_MOVDUP, ATOM_SSE_ATTR_LFENCE, ATOM_SSE_ATTR_FENCE, ATOM_SSE_ATTR_PREFETCH, ATOM_SSE_ATTR_SQRT, ATOM_SSE_ATTR_MXCSR, ATOM_SSE_ATTR_OTHER};
enum attr_i7_domain {I7_DOMAIN_INT, I7_DOMAIN_FLOAT, I7_DOMAIN_SIMD};
enum attr_hsw_domain {HSW_DOMAIN_INT, HSW_DOMAIN_FLOAT, HSW_DOMAIN_SIMD};
enum attr_unord_subst {UNORD_SUBST_NO, UNORD_SUBST_YES};
enum attr_mask {MASK_NO, MASK_YES};
enum attr_merge_mask {MERGE_MASK_NO, MERGE_MASK_YES};
enum attr_mask_scalar_merge {MASK_SCALAR_MERGE_NO, MASK_SCALAR_MERGE_YES};
enum attr_sd {SD_NO, SD_YES};
enum attr_round {ROUND_NO, ROUND_YES};
enum attr_round_saeonly {ROUND_SAEONLY_NO, ROUND_SAEONLY_YES};
enum attr_round_expand {ROUND_EXPAND_NO, ROUND_EXPAND_YES};
enum attr_round_saeonly_expand {ROUND_SAEONLY_EXPAND_NO, ROUND_SAEONLY_EXPAND_YES};
enum attr_mask_expand4 {MASK_EXPAND4_NO, MASK_EXPAND4_YES};
enum attr_mask_scalar {MASK_SCALAR_NO, MASK_SCALAR_YES};
enum attr_round_scalar {ROUND_SCALAR_NO, ROUND_SCALAR_YES};
enum attr_round_saeonly_scalar {ROUND_SAEONLY_SCALAR_NO, ROUND_SAEONLY_SCALAR_YES};
enum attr_maskz_half {MASKZ_HALF_NO, MASKZ_HALF_YES};
# 2512 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/config/i386/i386-cpuinfo.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/config/i386/i386-cpuinfo.h"
enum processor_vendor
{
VENDOR_INTEL = 1,
VENDOR_AMD,
VENDOR_OTHER,
VENDOR_CENTAUR,
VENDOR_CYRIX,
VENDOR_NSC,
BUILTIN_VENDOR_MAX = VENDOR_OTHER,
VENDOR_MAX
};
enum processor_types
{
INTEL_BONNELL = 1,
INTEL_CORE2,
INTEL_COREI7,
AMDFAM10H,
AMDFAM15H,
INTEL_SILVERMONT,
INTEL_KNL,
AMD_BTVER1,
AMD_BTVER2,
AMDFAM17H,
INTEL_KNM,
INTEL_GOLDMONT,
INTEL_GOLDMONT_PLUS,
INTEL_TREMONT,
CPU_TYPE_MAX,
BUILTIN_CPU_TYPE_MAX = CPU_TYPE_MAX
};
enum processor_subtypes
{
INTEL_COREI7_NEHALEM = 1,
INTEL_COREI7_WESTMERE,
INTEL_COREI7_SANDYBRIDGE,
AMDFAM10H_BARCELONA,
AMDFAM10H_SHANGHAI,
AMDFAM10H_ISTANBUL,
AMDFAM15H_BDVER1,
AMDFAM15H_BDVER2,
AMDFAM15H_BDVER3,
AMDFAM15H_BDVER4,
AMDFAM17H_ZNVER1,
INTEL_COREI7_IVYBRIDGE,
INTEL_COREI7_HASWELL,
INTEL_COREI7_BROADWELL,
INTEL_COREI7_SKYLAKE,
INTEL_COREI7_SKYLAKE_AVX512,
INTEL_COREI7_CANNONLAKE,
INTEL_COREI7_ICELAKE_CLIENT,
INTEL_COREI7_ICELAKE_SERVER,
AMDFAM17H_ZNVER2,
INTEL_COREI7_CASCADELAKE,
INTEL_COREI7_TIGERLAKE,
INTEL_COREI7_COOPERLAKE,
INTEL_COREI7_SAPPHIRERAPIDS,
INTEL_COREI7_ALDERLAKE,
CPU_SUBTYPE_MAX
};
enum feature_priority
{
P_NONE = 0,
P_MMX,
P_SSE,
P_SSE2,
P_SSE3,
P_SSSE3,
P_PROC_SSSE3,
P_SSE4_A,
P_PROC_SSE4_A,
P_SSE4_1,
P_SSE4_2,
P_PROC_SSE4_2,
P_POPCNT,
P_AES,
P_PCLMUL,
P_AVX,
P_PROC_AVX,
P_BMI,
P_PROC_BMI,
P_FMA4,
P_XOP,
P_PROC_XOP,
P_FMA,
P_PROC_FMA,
P_BMI2,
P_AVX2,
P_PROC_AVX2,
P_AVX512F,
P_PROC_AVX512F,
P_PROC_DYNAMIC
};
enum processor_features
{
FEATURE_CMOV = 0,
FEATURE_MMX,
FEATURE_POPCNT,
FEATURE_SSE,
FEATURE_SSE2,
FEATURE_SSE3,
FEATURE_SSSE3,
FEATURE_SSE4_1,
FEATURE_SSE4_2,
FEATURE_AVX,
FEATURE_AVX2,
FEATURE_SSE4_A,
FEATURE_FMA4,
FEATURE_XOP,
FEATURE_FMA,
FEATURE_AVX512F,
FEATURE_BMI,
FEATURE_BMI2,
FEATURE_AES,
FEATURE_PCLMUL,
FEATURE_AVX512VL,
FEATURE_AVX512BW,
FEATURE_AVX512DQ,
FEATURE_AVX512CD,
FEATURE_AVX512ER,
FEATURE_AVX512PF,
FEATURE_AVX512VBMI,
FEATURE_AVX512IFMA,
FEATURE_AVX5124VNNIW,
FEATURE_AVX5124FMAPS,
FEATURE_AVX512VPOPCNTDQ,
FEATURE_AVX512VBMI2,
FEATURE_GFNI,
FEATURE_VPCLMULQDQ,
FEATURE_AVX512VNNI,
FEATURE_AVX512BITALG,
FEATURE_AVX512BF16,
FEATURE_AVX512VP2INTERSECT,
FEATURE_3DNOW,
FEATURE_3DNOWP,
FEATURE_ADX,
FEATURE_ABM,
FEATURE_CLDEMOTE,
FEATURE_CLFLUSHOPT,
FEATURE_CLWB,
FEATURE_CLZERO,
FEATURE_CMPXCHG16B,
FEATURE_CMPXCHG8B,
FEATURE_ENQCMD,
FEATURE_F16C,
FEATURE_FSGSBASE,
FEATURE_FXSAVE,
FEATURE_HLE,
FEATURE_IBT,
FEATURE_LAHF_LM,
FEATURE_LM,
FEATURE_LWP,
FEATURE_LZCNT,
FEATURE_MOVBE,
FEATURE_MOVDIR64B,
FEATURE_MOVDIRI,
FEATURE_MWAITX,
FEATURE_OSXSAVE,
FEATURE_PCONFIG,
FEATURE_PKU,
FEATURE_PREFETCHWT1,
FEATURE_PRFCHW,
FEATURE_PTWRITE,
FEATURE_RDPID,
FEATURE_RDRND,
FEATURE_RDSEED,
FEATURE_RTM,
FEATURE_SERIALIZE,
FEATURE_SGX,
FEATURE_SHA,
FEATURE_SHSTK,
FEATURE_TBM,
FEATURE_TSXLDTRK,
FEATURE_VAES,
FEATURE_WAITPKG,
FEATURE_WBNOINVD,
FEATURE_XSAVE,
FEATURE_XSAVEC,
FEATURE_XSAVEOPT,
FEATURE_XSAVES,
CPU_FEATURE_MAX
};
# 2514 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h" 2
class pta
{
public:
const char *const name;
const enum processor_type processor;
const enum attr_cpu schedule;
const wide_int_bitmask flags;
const int model;
const enum feature_priority priority;
};
extern const pta processor_alias_table[];
extern int const pta_size;
extern unsigned int const num_arch_names;
extern enum processor_type ix86_tune;
extern enum processor_type ix86_arch;
extern unsigned int ix86_preferred_stack_boundary;
extern unsigned int ix86_incoming_stack_boundary;
extern enum reg_class const regclass_map[76];
enum ix86_fpcmp_strategy {
IX86_FPCMP_SAHF,
IX86_FPCMP_COMI,
IX86_FPCMP_ARITH
};
# 2568 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
enum ix86_stack_slot
{
SLOT_TEMP = 0,
SLOT_CW_STORED,
SLOT_CW_ROUNDEVEN,
SLOT_CW_TRUNC,
SLOT_CW_FLOOR,
SLOT_CW_CEIL,
SLOT_STV_TEMP,
MAX_386_STACK_LOCALS
};
enum ix86_entity
{
X86_DIRFLAG = 0,
AVX_U128,
I387_ROUNDEVEN,
I387_TRUNC,
I387_FLOOR,
I387_CEIL,
MAX_386_ENTITIES
};
enum x86_dirflag_state
{
X86_DIRFLAG_RESET,
X86_DIRFLAG_ANY
};
enum avx_u128_state
{
AVX_U128_CLEAN,
AVX_U128_DIRTY,
AVX_U128_ANY
};
# 2681 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
struct ix86_frame
{
int nsseregs;
int nregs;
int va_arg_size;
int red_zone_size;
int outgoing_arguments_size;
long frame_pointer_offset;
long hard_frame_pointer_offset;
long stack_pointer_offset;
long hfp_save_offset;
long reg_save_offset;
long stack_realign_allocate;
long stack_realign_offset;
long sse_reg_save_offset;
bool save_regs_using_mov;
bool expensive_p;
int expensive_count;
};
struct machine_frame_state
{
rtx cfa_reg;
long cfa_offset;
long sp_offset;
long fp_offset;
int red_zone_offset;
unsigned int sp_valid : 1;
unsigned int fp_valid : 1;
unsigned int drap_valid : 1;
unsigned int realigned : 1;
unsigned int sp_realigned : 1;
long sp_realigned_fp_last;
long sp_realigned_offset;
};
struct seh_frame_state;
enum function_type
{
TYPE_UNKNOWN = 0,
TYPE_NORMAL,
TYPE_INTERRUPT,
TYPE_EXCEPTION
};
enum queued_insn_type
{
TYPE_NONE = 0,
TYPE_ENDBR,
TYPE_PATCHABLE_AREA
};
struct machine_function {
struct stack_local_entry *stack_locals;
int varargs_gpr_size;
int varargs_fpr_size;
int optimize_mode_switching[MAX_386_ENTITIES];
struct ix86_frame frame;
rtx split_stack_varargs_pointer;
enum calling_abi call_abi : 8;
unsigned int accesses_prev_frame : 1;
unsigned int use_fast_prologue_epilogue : 1;
unsigned int pc_thunk_call_expanded : 1;
# 2828 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
unsigned int tls_descriptor_call_expanded_p : 1;
unsigned int static_chain_on_stack : 1;
unsigned int no_drap_save_restore : 1;
enum function_type func_type : 2;
enum indirect_branch indirect_branch_type : 3;
unsigned int has_local_indirect_jump : 1;
enum indirect_branch function_return_type : 3;
unsigned int no_caller_saved_registers : 1;
unsigned int arg_reg_available : 1;
unsigned int call_ms2sysv : 1;
unsigned int call_ms2sysv_pad_in : 1;
unsigned int call_ms2sysv_extra_regs:3;
unsigned int outgoing_args_on_stack : 1;
enum queued_insn_type insn_queued_at_entrance : 2;
unsigned int function_label_emitted : 1;
unsigned int stack_frame_required : 1;
unsigned int max_used_stack_alignment;
struct machine_frame_state fs;
struct seh_frame_state * seh;
};
extern tree sysv_va_list_type_node;
extern tree ms_va_list_type_node;
# 2942 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
extern void debug_ready_dispatch (void);
extern void debug_dispatch_window (int);
# 2998 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/i386.h"
extern enum attr_cpu ix86_schedule;
# 27 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/unix.h" 1
# 28 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/att.h" 1
# 29 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/dbxelf.h" 1
# 30 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/elfos.h" 1
# 31 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/gnu-user.h" 1
# 32 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/glibc-stdint.h" 1
# 33 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/x86-64.h" 1
# 34 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/gnu-user-common.h" 1
# 35 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/gnu-user64.h" 1
# 36 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/linux.h" 1
# 37 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/linux-android.h" 1
# 38 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/linux-common.h" 1
# 71 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/linux-common.h"
extern void file_end_indicate_exec_stack_and_cet (void);
# 39 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/i386/linux64.h" 1
# 40 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/config/initfini-array.h" 1
# 41 "./tm.h" 2
# 1 "./insn-flags.h" 1
# 7286 "./insn-flags.h"
extern rtx gen_x86_sahf_1 (rtx);
extern rtx gen_insvhi_1 (rtx, rtx);
extern rtx gen_insvsi_1 (rtx, rtx);
extern rtx gen_insvdi_1 (rtx, rtx);
extern rtx gen_zero_extendqidi2 (rtx, rtx);
extern rtx gen_zero_extendhidi2 (rtx, rtx);
extern rtx gen_zero_extendqisi2_and (rtx, rtx);
extern rtx gen_zero_extendhisi2_and (rtx, rtx);
extern rtx gen_zero_extendqihi2_and (rtx, rtx);
extern rtx gen_extendsidi2_1 (rtx, rtx);
extern rtx gen_extendqidi2 (rtx, rtx);
extern rtx gen_extendhidi2 (rtx, rtx);
extern rtx gen_extendhisi2 (rtx, rtx);
extern rtx gen_extendqisi2 (rtx, rtx);
extern rtx gen_extendqihi2 (rtx, rtx);
extern rtx gen_truncdfsf2 (rtx, rtx);
extern rtx gen_truncxfsf2 (rtx, rtx);
extern rtx gen_truncxfdf2 (rtx, rtx);
extern rtx gen_fixuns_truncsfdi2 (rtx, rtx);
extern rtx gen_fixuns_truncdfdi2 (rtx, rtx);
extern rtx gen_fixuns_truncsfsi2_avx512f (rtx, rtx);
extern rtx gen_fixuns_truncdfsi2_avx512f (rtx, rtx);
extern rtx gen_fix_truncsfsi_sse (rtx, rtx);
extern rtx gen_fix_truncsfdi_sse (rtx, rtx);
extern rtx gen_fix_truncdfsi_sse (rtx, rtx);
extern rtx gen_fix_truncdfdi_sse (rtx, rtx);
extern rtx gen_fix_trunchi_i387_fisttp (rtx, rtx);
extern rtx gen_fix_truncsi_i387_fisttp (rtx, rtx);
extern rtx gen_fix_truncdi_i387_fisttp (rtx, rtx);
extern rtx gen_fix_truncdi_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_fix_trunchi_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncsi_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_x86_fnstcw_1 (rtx);
extern rtx gen_floathisf2 (rtx, rtx);
extern rtx gen_floathidf2 (rtx, rtx);
extern rtx gen_floathixf2 (rtx, rtx);
extern rtx gen_floatsixf2 (rtx, rtx);
extern rtx gen_floatdixf2 (rtx, rtx);
extern rtx gen_floatdisf2_i387_with_xmm (rtx, rtx, rtx);
extern rtx gen_floatdidf2_i387_with_xmm (rtx, rtx, rtx);
extern rtx gen_floatdixf2_i387_with_xmm (rtx, rtx, rtx);
extern rtx gen_floatunssisf2_i387_with_xmm (rtx, rtx, rtx);
extern rtx gen_floatunssidf2_i387_with_xmm (rtx, rtx, rtx);
extern rtx gen_floatunssixf2_i387_with_xmm (rtx, rtx, rtx);
extern rtx gen_addsi_1_zext (rtx, rtx, rtx);
extern rtx gen_addvqi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_addvhi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_addvsi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_addvdi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_subvqi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_subvhi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_subvsi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_subvdi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_addqi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addhi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addsi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_adddi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addcarrysi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addcarrydi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subqi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subhi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subsi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subdi3_carry (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subsi3_carry_ccc (rtx, rtx, rtx);
extern rtx gen_subdi3_carry_ccc (rtx, rtx, rtx);
extern rtx gen_subsi3_carry_ccgz (rtx, rtx, rtx);
extern rtx gen_subdi3_carry_ccgz (rtx, rtx, rtx);
extern rtx gen_subborrowsi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subborrowdi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_divmodsi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_divmoddi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmodsi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmoddi4_1 (rtx, rtx, rtx, rtx);
extern rtx gen_divmodsi4_zext_1 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmodsi4_zext_1 (rtx, rtx, rtx, rtx);
extern rtx gen_divmodsi4_zext_2 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmodsi4_zext_2 (rtx, rtx, rtx, rtx);
extern rtx gen_divmodhiqi3 (rtx, rtx, rtx);
extern rtx gen_udivmodhiqi3 (rtx, rtx, rtx);
extern rtx gen_copysignsf3_const (rtx, rtx, rtx, rtx);
extern rtx gen_copysigndf3_const (rtx, rtx, rtx, rtx);
extern rtx gen_copysigntf3_const (rtx, rtx, rtx, rtx);
extern rtx gen_copysignsf3_var (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_copysigndf3_var (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_copysigntf3_var (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorsignsf3_1 (rtx, rtx, rtx, rtx);
extern rtx gen_xorsigndf3_1 (rtx, rtx, rtx, rtx);
extern rtx gen_x86_64_shld (rtx, rtx, rtx);
extern rtx gen_x86_shld (rtx, rtx, rtx);
extern rtx gen_x86_64_shrd (rtx, rtx, rtx);
extern rtx gen_x86_shrd (rtx, rtx, rtx);
extern rtx gen_ashrsi3_cvt (rtx, rtx, rtx);
extern rtx gen_ashrdi3_cvt (rtx, rtx, rtx);
extern rtx gen_ix86_rotldi3_doubleword (rtx, rtx, rtx);
extern rtx gen_ix86_rotlti3_doubleword (rtx, rtx, rtx);
extern rtx gen_ix86_rotrdi3_doubleword (rtx, rtx, rtx);
extern rtx gen_ix86_rotrti3_doubleword (rtx, rtx, rtx);
extern rtx gen_setcc_sf_sse (rtx, rtx, rtx, rtx);
extern rtx gen_setcc_df_sse (rtx, rtx, rtx, rtx);
extern rtx gen_jump (rtx);
extern rtx gen_blockage (void);
extern rtx gen_prologue_use (rtx);
extern rtx gen_simple_return_internal (void);
extern rtx gen_interrupt_return (void);
extern rtx gen_simple_return_internal_long (void);
extern rtx gen_simple_return_pop_internal (rtx);
extern rtx gen_nop (void);
extern rtx gen_nops (rtx);
extern rtx gen_pad (rtx);
extern rtx gen_set_got_rex64 (rtx);
extern rtx gen_set_rip_rex64 (rtx, rtx);
extern rtx gen_set_got_offset_rex64 (rtx, rtx);
extern rtx gen_eh_return_internal (void);
extern rtx gen_split_stack_return (rtx);
extern rtx gen_ffssi2_no_cmove (rtx, rtx);
extern rtx gen_ctzsi2 (rtx, rtx);
extern rtx gen_ctzdi2 (rtx, rtx);
extern rtx gen_bsr_rex64 (rtx, rtx);
extern rtx gen_bsr (rtx, rtx);
extern rtx gen_clzsi2_lzcnt (rtx, rtx);
extern rtx gen_clzdi2_lzcnt (rtx, rtx);
extern rtx gen_tzcnt_si (rtx, rtx);
extern rtx gen_lzcnt_si (rtx, rtx);
extern rtx gen_tzcnt_di (rtx, rtx);
extern rtx gen_lzcnt_di (rtx, rtx);
extern rtx gen_tzcnt_hi (rtx, rtx);
extern rtx gen_lzcnt_hi (rtx, rtx);
extern rtx gen_bmi_bextr_si (rtx, rtx, rtx);
extern rtx gen_bmi_bextr_di (rtx, rtx, rtx);
extern rtx gen_bmi2_pdep_si3 (rtx, rtx, rtx);
extern rtx gen_bmi2_pdep_di3 (rtx, rtx, rtx);
extern rtx gen_bmi2_pext_si3 (rtx, rtx, rtx);
extern rtx gen_bmi2_pext_di3 (rtx, rtx, rtx);
extern rtx gen_popcountsi2 (rtx, rtx);
extern rtx gen_popcountdi2 (rtx, rtx);
extern rtx gen_popcounthi2 (rtx, rtx);
extern rtx gen_bswaphi_lowpart (rtx);
extern rtx gen_parityhi2_cmp (rtx);
extern rtx gen_parityqi2_cmp (rtx);
static inline rtx gen_tls_initial_exec_64_sun (rtx, rtx);
static inline rtx
gen_tls_initial_exec_64_sun(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_truncxfsf2_i387_noop_unspec (rtx, rtx);
extern rtx gen_truncxfdf2_i387_noop_unspec (rtx, rtx);
extern rtx gen_sqrtxf2 (rtx, rtx);
extern rtx gen_x86_fnstsw_1 (rtx);
extern rtx gen_fpremxf4_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_fprem1xf4_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_sinxf2 (rtx, rtx);
extern rtx gen_cosxf2 (rtx, rtx);
extern rtx gen_sincosxf3 (rtx, rtx, rtx);
extern rtx gen_fptanxf4_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_atan2xf3 (rtx, rtx, rtx);
extern rtx gen_fyl2xxf3_i387 (rtx, rtx, rtx);
extern rtx gen_fyl2xp1xf3_i387 (rtx, rtx, rtx);
extern rtx gen_fxtractxf3_i387 (rtx, rtx, rtx);
extern rtx gen_fscalexf4_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_roundsf2 (rtx, rtx, rtx);
extern rtx gen_sse4_1_rounddf2 (rtx, rtx, rtx);
extern rtx gen_rintxf2 (rtx, rtx);
extern rtx gen_lrintxfdi2 (rtx, rtx);
extern rtx gen_lrintxfhi2 (rtx, rtx);
extern rtx gen_lrintxfsi2 (rtx, rtx);
extern rtx gen_frndintxf2_roundeven (rtx, rtx);
extern rtx gen_frndintxf2_floor (rtx, rtx);
extern rtx gen_frndintxf2_ceil (rtx, rtx);
extern rtx gen_frndintxf2_trunc (rtx, rtx);
extern rtx gen_frndintxf2_roundeven_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_frndintxf2_floor_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_frndintxf2_ceil_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_frndintxf2_trunc_i387 (rtx, rtx, rtx, rtx);
extern rtx gen_fistdi2_floor (rtx, rtx, rtx, rtx);
extern rtx gen_fistdi2_ceil (rtx, rtx, rtx, rtx);
extern rtx gen_fisthi2_floor (rtx, rtx, rtx, rtx);
extern rtx gen_fisthi2_ceil (rtx, rtx, rtx, rtx);
extern rtx gen_fistsi2_floor (rtx, rtx, rtx, rtx);
extern rtx gen_fistsi2_ceil (rtx, rtx, rtx, rtx);
extern rtx gen_fxamsf2_i387 (rtx, rtx);
extern rtx gen_fxamdf2_i387 (rtx, rtx);
extern rtx gen_fxamxf2_i387 (rtx, rtx);
extern rtx gen_movmsk_df (rtx, rtx);
extern rtx gen_cld (void);
extern rtx gen_smaxsf3 (rtx, rtx, rtx);
extern rtx gen_sminsf3 (rtx, rtx, rtx);
extern rtx gen_smaxdf3 (rtx, rtx, rtx);
extern rtx gen_smindf3 (rtx, rtx, rtx);
extern rtx gen_pro_epilogue_adjust_stack_add_si (rtx, rtx, rtx);
extern rtx gen_pro_epilogue_adjust_stack_add_di (rtx, rtx, rtx);
extern rtx gen_pro_epilogue_adjust_stack_sub_si (rtx, rtx, rtx);
extern rtx gen_pro_epilogue_adjust_stack_sub_di (rtx, rtx, rtx);
extern rtx gen_allocate_stack_worker_probe_si (rtx, rtx);
extern rtx gen_allocate_stack_worker_probe_di (rtx, rtx);
extern rtx gen_probe_stack_1_si (rtx, rtx);
extern rtx gen_probe_stack_1_di (rtx, rtx);
extern rtx gen_adjust_stack_and_probe_si (rtx, rtx, rtx);
extern rtx gen_adjust_stack_and_probe_di (rtx, rtx, rtx);
extern rtx gen_probe_stack_range_si (rtx, rtx, rtx);
extern rtx gen_probe_stack_range_di (rtx, rtx, rtx);
extern rtx gen_trap (void);
extern rtx gen_ud2 (void);
extern rtx gen_stack_protect_set_1_si (rtx, rtx);
extern rtx gen_stack_protect_set_1_di (rtx, rtx);
extern rtx gen_stack_protect_test_1_si (rtx, rtx, rtx);
extern rtx gen_stack_protect_test_1_di (rtx, rtx, rtx);
extern rtx gen_sse4_2_crc32qi (rtx, rtx, rtx);
extern rtx gen_sse4_2_crc32hi (rtx, rtx, rtx);
extern rtx gen_sse4_2_crc32si (rtx, rtx, rtx);
extern rtx gen_sse4_2_crc32di (rtx, rtx, rtx);
extern rtx gen_rdpmc (rtx, rtx);
extern rtx gen_rdpmc_rex64 (rtx, rtx, rtx);
extern rtx gen_rdtsc (rtx);
extern rtx gen_rdtsc_rex64 (rtx, rtx);
extern rtx gen_rdtscp (rtx, rtx);
extern rtx gen_rdtscp_rex64 (rtx, rtx, rtx);
extern rtx gen_fxsave (rtx);
extern rtx gen_fxsave64 (rtx);
extern rtx gen_fxrstor (rtx);
extern rtx gen_fxrstor64 (rtx);
extern rtx gen_xsave (rtx, rtx);
extern rtx gen_xsaveopt (rtx, rtx);
extern rtx gen_xsavec (rtx, rtx);
extern rtx gen_xsaves (rtx, rtx);
extern rtx gen_xsave_rex64 (rtx, rtx, rtx);
extern rtx gen_xsaveopt_rex64 (rtx, rtx, rtx);
extern rtx gen_xsavec_rex64 (rtx, rtx, rtx);
extern rtx gen_xsaves_rex64 (rtx, rtx, rtx);
extern rtx gen_xsave64 (rtx, rtx, rtx);
extern rtx gen_xsaveopt64 (rtx, rtx, rtx);
extern rtx gen_xsavec64 (rtx, rtx, rtx);
extern rtx gen_xsaves64 (rtx, rtx, rtx);
extern rtx gen_xrstor (rtx, rtx);
extern rtx gen_xrstors (rtx, rtx);
extern rtx gen_xrstor_rex64 (rtx, rtx, rtx);
extern rtx gen_xrstors_rex64 (rtx, rtx, rtx);
extern rtx gen_xrstor64 (rtx, rtx, rtx);
extern rtx gen_xrstors64 (rtx, rtx, rtx);
extern rtx gen_xsetbv (rtx, rtx);
extern rtx gen_xsetbv_rex64 (rtx, rtx, rtx);
extern rtx gen_xgetbv (rtx, rtx);
extern rtx gen_xgetbv_rex64 (rtx, rtx, rtx);
extern rtx gen_fnstenv (rtx);
extern rtx gen_fldenv (rtx);
extern rtx gen_fnstsw (rtx);
extern rtx gen_fnclex (void);
extern rtx gen_lwp_llwpcbsi (rtx);
extern rtx gen_lwp_llwpcbdi (rtx);
extern rtx gen_lwp_slwpcbsi (rtx);
extern rtx gen_lwp_slwpcbdi (rtx);
extern rtx gen_lwp_lwpvalsi (rtx, rtx, rtx);
extern rtx gen_lwp_lwpvaldi (rtx, rtx, rtx);
extern rtx gen_lwp_lwpinssi (rtx, rtx, rtx);
extern rtx gen_lwp_lwpinsdi (rtx, rtx, rtx);
extern rtx gen_rdfsbasesi (rtx);
extern rtx gen_rdgsbasesi (rtx);
extern rtx gen_rdfsbasedi (rtx);
extern rtx gen_rdgsbasedi (rtx);
extern rtx gen_wrfsbasesi (rtx);
extern rtx gen_wrgsbasesi (rtx);
extern rtx gen_wrfsbasedi (rtx);
extern rtx gen_wrgsbasedi (rtx);
extern rtx gen_ptwritesi (rtx);
extern rtx gen_ptwritedi (rtx);
extern rtx gen_rdrandhi_1 (rtx);
extern rtx gen_rdrandsi_1 (rtx);
extern rtx gen_rdranddi_1 (rtx);
extern rtx gen_rdseedhi_1 (rtx);
extern rtx gen_rdseedsi_1 (rtx);
extern rtx gen_rdseeddi_1 (rtx);
extern rtx gen_rdsspsi (rtx, rtx);
extern rtx gen_rdsspdi (rtx, rtx);
extern rtx gen_incsspsi (rtx);
extern rtx gen_incsspdi (rtx);
extern rtx gen_saveprevssp (void);
extern rtx gen_rstorssp (rtx);
extern rtx gen_wrsssi (rtx, rtx);
extern rtx gen_wrssdi (rtx, rtx);
extern rtx gen_wrusssi (rtx, rtx);
extern rtx gen_wrussdi (rtx, rtx);
extern rtx gen_setssbsy (void);
extern rtx gen_clrssbsy (rtx);
extern rtx gen_nop_endbr (void);
extern rtx gen_xbegin_1 (rtx, rtx);
extern rtx gen_xend (void);
extern rtx gen_xabort (rtx);
extern rtx gen_xtest_1 (void);
extern rtx gen_clwb (rtx);
extern rtx gen_clflushopt (rtx);
extern rtx gen_mwaitx (rtx, rtx, rtx);
extern rtx gen_monitorx_si (rtx, rtx, rtx);
extern rtx gen_monitorx_di (rtx, rtx, rtx);
extern rtx gen_clzero_si (rtx);
extern rtx gen_clzero_di (rtx);
extern rtx gen_rdpid (rtx);
extern rtx gen_rdpid_rex64 (rtx);
extern rtx gen_wbinvd (void);
extern rtx gen_wbnoinvd (void);
extern rtx gen_movdirisi (rtx, rtx);
extern rtx gen_movdiridi (rtx, rtx);
extern rtx gen_movdir64b_si (rtx, rtx);
extern rtx gen_movdir64b_di (rtx, rtx);
extern rtx gen_xsusldtrk (void);
extern rtx gen_xresldtrk (void);
extern rtx gen_enqcmd_si (rtx, rtx);
extern rtx gen_enqcmds_si (rtx, rtx);
extern rtx gen_enqcmd_di (rtx, rtx);
extern rtx gen_enqcmds_di (rtx, rtx);
extern rtx gen_umwait (rtx, rtx);
extern rtx gen_umwait_rex64 (rtx, rtx, rtx);
extern rtx gen_umonitor_si (rtx);
extern rtx gen_umonitor_di (rtx);
extern rtx gen_tpause (rtx, rtx);
extern rtx gen_tpause_rex64 (rtx, rtx, rtx);
extern rtx gen_cldemote (rtx);
extern rtx gen_speculation_barrier (void);
extern rtx gen_serialize (void);
extern rtx gen_patchable_area (rtx, rtx);
extern rtx gen_sse_movntq (rtx, rtx);
extern rtx gen_mmx_ieee_maxv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_ieee_minv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_rcpv2sf2 (rtx, rtx);
extern rtx gen_mmx_rcpit1v2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_rcpit2v2sf3 (rtx, rtx, rtx);
extern rtx gen_sqrtv2sf2 (rtx, rtx);
extern rtx gen_mmx_rsqrtv2sf2 (rtx, rtx);
extern rtx gen_mmx_rsqit1v2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_hsubv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_gtv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_gev2sf3 (rtx, rtx, rtx);
extern rtx gen_fmav2sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv2sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav2sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv2sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_mmx_fix_truncv2sfv2si2 (rtx, rtx);
extern rtx gen_fixuns_truncv2sfv2si2 (rtx, rtx);
extern rtx gen_mmx_floatv2siv2sf2 (rtx, rtx);
extern rtx gen_floatunsv2siv2sf2 (rtx, rtx);
extern rtx gen_mmx_pf2iw (rtx, rtx);
extern rtx gen_mmx_pi2fw (rtx, rtx);
extern rtx gen_mmx_pswapdv2sf2 (rtx, rtx);
extern rtx gen_mmx_ashrv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_ashrv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_ashlv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_lshrv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_ashlv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_lshrv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_ashlv1di3 (rtx, rtx, rtx);
extern rtx gen_mmx_lshrv1di3 (rtx, rtx, rtx);
extern rtx gen_mmx_gtv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_gtv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_gtv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_andnotv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_andnotv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_andnotv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_packsswb (rtx, rtx, rtx);
extern rtx gen_mmx_packuswb (rtx, rtx, rtx);
extern rtx gen_mmx_packssdw (rtx, rtx, rtx);
extern rtx gen_mmx_punpckhbw (rtx, rtx, rtx);
extern rtx gen_mmx_punpcklbw (rtx, rtx, rtx);
extern rtx gen_mmx_punpckhwd (rtx, rtx, rtx);
extern rtx gen_mmx_punpcklwd (rtx, rtx, rtx);
extern rtx gen_mmx_punpckhdq (rtx, rtx, rtx);
extern rtx gen_mmx_punpckldq (rtx, rtx, rtx);
extern rtx gen_mmx_pshufw_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mmx_pswapdv2si2 (rtx, rtx);
extern rtx gen_mmx_psadbw (rtx, rtx, rtx);
extern rtx gen_mmx_pmovmskb (rtx, rtx);
extern rtx gen_movv64qi_internal (rtx, rtx);
extern rtx gen_movv32qi_internal (rtx, rtx);
extern rtx gen_movv16qi_internal (rtx, rtx);
extern rtx gen_movv32hi_internal (rtx, rtx);
extern rtx gen_movv16hi_internal (rtx, rtx);
extern rtx gen_movv8hi_internal (rtx, rtx);
extern rtx gen_movv16si_internal (rtx, rtx);
extern rtx gen_movv8si_internal (rtx, rtx);
extern rtx gen_movv4si_internal (rtx, rtx);
extern rtx gen_movv8di_internal (rtx, rtx);
extern rtx gen_movv4di_internal (rtx, rtx);
extern rtx gen_movv2di_internal (rtx, rtx);
extern rtx gen_movv4ti_internal (rtx, rtx);
extern rtx gen_movv2ti_internal (rtx, rtx);
extern rtx gen_movv1ti_internal (rtx, rtx);
extern rtx gen_movv16sf_internal (rtx, rtx);
extern rtx gen_movv8sf_internal (rtx, rtx);
extern rtx gen_movv4sf_internal (rtx, rtx);
extern rtx gen_movv8df_internal (rtx, rtx);
extern rtx gen_movv4df_internal (rtx, rtx);
extern rtx gen_movv2df_internal (rtx, rtx);
extern rtx gen_avx512f_loadv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_loadv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_loadv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_loadv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_loadv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_loadv32hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv16hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_loadv8hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_movsf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_movdf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_storesf_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_storedf_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_storev16si_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev8si_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev4si_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_storev8di_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev4di_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev2di_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_storev16sf_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev8sf_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev4sf_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_storev8df_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev4df_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev2df_mask (rtx, rtx, rtx);
extern rtx gen_avx512bw_storev64qi_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev16qi_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev32qi_mask (rtx, rtx, rtx);
extern rtx gen_avx512bw_storev32hi_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev16hi_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_storev8hi_mask (rtx, rtx, rtx);
extern rtx gen_sse2_movq128 (rtx, rtx);
extern rtx gen_movdi_to_sse (rtx, rtx);
extern rtx gen_avx_lddqu256 (rtx, rtx);
extern rtx gen_sse3_lddqu (rtx, rtx);
extern rtx gen_sse2_movntisi (rtx, rtx);
extern rtx gen_sse2_movntidi (rtx, rtx);
extern rtx gen_avx512f_movntv16sf (rtx, rtx);
extern rtx gen_avx_movntv8sf (rtx, rtx);
extern rtx gen_sse_movntv4sf (rtx, rtx);
extern rtx gen_avx512f_movntv8df (rtx, rtx);
extern rtx gen_avx_movntv4df (rtx, rtx);
extern rtx gen_sse2_movntv2df (rtx, rtx);
extern rtx gen_avx512f_movntv8di (rtx, rtx);
extern rtx gen_avx_movntv4di (rtx, rtx);
extern rtx gen_sse2_movntv2di (rtx, rtx);
extern rtx gen_kandqi (rtx, rtx, rtx);
extern rtx gen_kiorqi (rtx, rtx, rtx);
extern rtx gen_kxorqi (rtx, rtx, rtx);
extern rtx gen_kandhi (rtx, rtx, rtx);
extern rtx gen_kiorhi (rtx, rtx, rtx);
extern rtx gen_kxorhi (rtx, rtx, rtx);
extern rtx gen_kandsi (rtx, rtx, rtx);
extern rtx gen_kiorsi (rtx, rtx, rtx);
extern rtx gen_kxorsi (rtx, rtx, rtx);
extern rtx gen_kanddi (rtx, rtx, rtx);
extern rtx gen_kiordi (rtx, rtx, rtx);
extern rtx gen_kxordi (rtx, rtx, rtx);
extern rtx gen_kandnqi (rtx, rtx, rtx);
extern rtx gen_kandnhi (rtx, rtx, rtx);
extern rtx gen_kandnsi (rtx, rtx, rtx);
extern rtx gen_kandndi (rtx, rtx, rtx);
extern rtx gen_kxnorqi (rtx, rtx, rtx);
extern rtx gen_kxnorhi (rtx, rtx, rtx);
extern rtx gen_kxnorsi (rtx, rtx, rtx);
extern rtx gen_kxnordi (rtx, rtx, rtx);
extern rtx gen_knotqi (rtx, rtx);
extern rtx gen_knothi (rtx, rtx);
extern rtx gen_knotsi (rtx, rtx);
extern rtx gen_knotdi (rtx, rtx);
extern rtx gen_kaddqi (rtx, rtx, rtx);
extern rtx gen_kaddhi (rtx, rtx, rtx);
extern rtx gen_kaddsi (rtx, rtx, rtx);
extern rtx gen_kadddi (rtx, rtx, rtx);
extern rtx gen_kashiftqi (rtx, rtx, rtx);
extern rtx gen_klshiftrtqi (rtx, rtx, rtx);
extern rtx gen_kashifthi (rtx, rtx, rtx);
extern rtx gen_klshiftrthi (rtx, rtx, rtx);
extern rtx gen_kashiftsi (rtx, rtx, rtx);
extern rtx gen_klshiftrtsi (rtx, rtx, rtx);
extern rtx gen_kashiftdi (rtx, rtx, rtx);
extern rtx gen_klshiftrtdi (rtx, rtx, rtx);
extern rtx gen_ktestqi (rtx, rtx);
extern rtx gen_ktesthi (rtx, rtx);
extern rtx gen_ktestsi (rtx, rtx);
extern rtx gen_ktestdi (rtx, rtx);
extern rtx gen_kortestqi (rtx, rtx);
extern rtx gen_kortesthi (rtx, rtx);
extern rtx gen_kortestsi (rtx, rtx);
extern rtx gen_kortestdi (rtx, rtx);
extern rtx gen_kunpckhi (rtx, rtx, rtx);
extern rtx gen_kunpcksi (rtx, rtx, rtx);
extern rtx gen_kunpckdi (rtx, rtx, rtx);
extern rtx gen_sse_vmaddv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_vmaddv4sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmaddv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmaddv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsubv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_vmsubv4sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsubv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsubv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmaddv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_vmaddv2df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmaddv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmaddv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsubv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_vmsubv2df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsubv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsubv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmmulv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_vmmulv4sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmmulv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmmulv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmdivv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_vmdivv4sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmdivv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmdivv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmmulv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_vmmulv2df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmmulv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmmulv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmdivv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_vmdivv2df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmdivv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmdivv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_divv16sf3 (rtx, rtx, rtx);
extern rtx gen_avx512f_divv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_divv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_divv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_divv8sf3 (rtx, rtx, rtx);
static inline rtx gen_avx_divv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_divv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx_divv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx_divv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_divv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse_divv4sf3 (rtx, rtx, rtx);
static inline rtx gen_sse_divv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_sse_divv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse_divv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_sse_divv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sse_divv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_divv8df3 (rtx, rtx, rtx);
extern rtx gen_avx512f_divv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_divv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_divv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_divv4df3 (rtx, rtx, rtx);
static inline rtx gen_avx_divv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_divv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx_divv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx_divv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_divv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse2_divv2df3 (rtx, rtx, rtx);
static inline rtx gen_sse2_divv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_sse2_divv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse2_divv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_sse2_divv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sse2_divv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx_rcpv8sf2 (rtx, rtx);
extern rtx gen_sse_rcpv4sf2 (rtx, rtx);
extern rtx gen_sse_vmrcpv4sf2 (rtx, rtx, rtx);
extern rtx gen_rcp14v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rcp14v8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rcp14v4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rcp14v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rcp14v4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rcp14v2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_srcp14v4sf (rtx, rtx, rtx);
extern rtx gen_srcp14v2df (rtx, rtx, rtx);
extern rtx gen_srcp14v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_srcp14v2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sqrtv16sf2 (rtx, rtx);
extern rtx gen_avx512f_sqrtv16sf2_round (rtx, rtx, rtx);
extern rtx gen_avx512f_sqrtv16sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sqrtv16sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_sqrtv8sf2 (rtx, rtx);
static inline rtx gen_avx_sqrtv8sf2_round (rtx, rtx, rtx);
static inline rtx
gen_avx_sqrtv8sf2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx_sqrtv8sf2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_avx_sqrtv8sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_sqrtv8sf2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse_sqrtv4sf2 (rtx, rtx);
static inline rtx gen_sse_sqrtv4sf2_round (rtx, rtx, rtx);
static inline rtx
gen_sse_sqrtv4sf2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse_sqrtv4sf2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_sse_sqrtv4sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sse_sqrtv4sf2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_sqrtv8df2 (rtx, rtx);
extern rtx gen_avx512f_sqrtv8df2_round (rtx, rtx, rtx);
extern rtx gen_avx512f_sqrtv8df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sqrtv8df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_sqrtv4df2 (rtx, rtx);
static inline rtx gen_avx_sqrtv4df2_round (rtx, rtx, rtx);
static inline rtx
gen_avx_sqrtv4df2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx_sqrtv4df2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_avx_sqrtv4df2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_sqrtv4df2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse2_sqrtv2df2 (rtx, rtx);
static inline rtx gen_sse2_sqrtv2df2_round (rtx, rtx, rtx);
static inline rtx
gen_sse2_sqrtv2df2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse2_sqrtv2df2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_sse2_sqrtv2df2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sse2_sqrtv2df2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse_vmsqrtv4sf2 (rtx, rtx, rtx);
extern rtx gen_sse_vmsqrtv4sf2_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsqrtv4sf2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsqrtv4sf2_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsqrtv2df2 (rtx, rtx, rtx);
extern rtx gen_sse2_vmsqrtv2df2_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsqrtv2df2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsqrtv2df2_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_rsqrtv8sf2 (rtx, rtx);
extern rtx gen_sse_rsqrtv4sf2 (rtx, rtx);
extern rtx gen_rsqrt14v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14v8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14v4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14v4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14v2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14v4sf (rtx, rtx, rtx);
extern rtx gen_rsqrt14v2df (rtx, rtx, rtx);
extern rtx gen_rsqrt14_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_rsqrt14_v2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmrsqrtv4sf2 (rtx, rtx, rtx);
extern rtx gen_ieee_maxv16sf3 (rtx, rtx, rtx);
extern rtx gen_ieee_maxv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_ieee_maxv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_maxv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_minv16sf3 (rtx, rtx, rtx);
extern rtx gen_ieee_minv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_ieee_minv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_minv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_maxv8sf3 (rtx, rtx, rtx);
static inline rtx gen_ieee_maxv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_maxv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv8sf3 (rtx, rtx, rtx);
static inline rtx gen_ieee_minv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_minv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv4sf3 (rtx, rtx, rtx);
static inline rtx gen_ieee_maxv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_maxv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv4sf3 (rtx, rtx, rtx);
static inline rtx gen_ieee_minv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_minv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv8df3 (rtx, rtx, rtx);
extern rtx gen_ieee_maxv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_ieee_maxv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_maxv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_minv8df3 (rtx, rtx, rtx);
extern rtx gen_ieee_minv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_ieee_minv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_minv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ieee_maxv4df3 (rtx, rtx, rtx);
static inline rtx gen_ieee_maxv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_maxv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv4df3 (rtx, rtx, rtx);
static inline rtx gen_ieee_minv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_minv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv2df3 (rtx, rtx, rtx);
static inline rtx gen_ieee_maxv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_maxv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_maxv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_maxv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv2df3 (rtx, rtx, rtx);
static inline rtx gen_ieee_minv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ieee_minv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_ieee_minv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ieee_minv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse_vmsmaxv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_vmsmaxv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsmaxv4sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsmaxv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsminv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_vmsminv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsminv4sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmsminv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsmaxv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_vmsmaxv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsmaxv2df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsmaxv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsminv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_vmsminv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsminv2df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmsminv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_addsubv4df3 (rtx, rtx, rtx);
extern rtx gen_sse3_addsubv2df3 (rtx, rtx, rtx);
extern rtx gen_avx_addsubv8sf3 (rtx, rtx, rtx);
extern rtx gen_sse3_addsubv4sf3 (rtx, rtx, rtx);
extern rtx gen_avx_haddv4df3 (rtx, rtx, rtx);
extern rtx gen_avx_hsubv4df3 (rtx, rtx, rtx);
extern rtx gen_sse3_hsubv2df3 (rtx, rtx, rtx);
extern rtx gen_avx_haddv8sf3 (rtx, rtx, rtx);
extern rtx gen_avx_hsubv8sf3 (rtx, rtx, rtx);
extern rtx gen_sse3_haddv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse3_hsubv4sf3 (rtx, rtx, rtx);
extern rtx gen_reducepv16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducepv8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducepv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducepv8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducepv4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducepv2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducesv4sf (rtx, rtx, rtx, rtx);
extern rtx gen_reducesv4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_reducesv2df (rtx, rtx, rtx, rtx);
extern rtx gen_reducesv2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_cmpv8sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_cmpv4sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_cmpv4df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_cmpv2df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vmcmpv4sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vmcmpv2df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_maskcmpv8sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_sse_maskcmpv4sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_maskcmpv4df3 (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_maskcmpv2df3 (rtx, rtx, rtx, rtx);
extern rtx gen_sse_vmmaskcmpv4sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_vmmaskcmpv2df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16si3_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16si3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv8si3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv8si3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv8si3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv8si3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv8si3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv8si3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv4si3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4si3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4si3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv4si3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4si3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4si3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_cmpv8di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv8di3_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv8di3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv4di3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4di3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4di3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv4di3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4di3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4di3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv2di3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv2di3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv2di3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv2di3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv2di3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv2di3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_cmpv16sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16sf3_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv8sf3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv8sf3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv4sf3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4sf3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_cmpv8df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv8df3_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cmpv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv4df3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4df3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv2df3 (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv2df3_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_cmpv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_cmpv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_cmpv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512bw_cmpv64qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_cmpv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv32qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_cmpv32hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_cmpv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv16hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_cmpv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ucmpv64qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ucmpv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv32qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ucmpv32hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ucmpv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv16hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ucmpv16si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ucmpv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv8si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv4si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ucmpv8di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ucmpv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv4di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv2di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ucmpv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv4sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv4sf3_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv2df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv2df3_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmcmpv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_comi (rtx, rtx);
extern rtx gen_sse_comi_round (rtx, rtx, rtx);
extern rtx gen_sse_ucomi (rtx, rtx);
extern rtx gen_sse_ucomi_round (rtx, rtx, rtx);
extern rtx gen_sse2_comi (rtx, rtx);
extern rtx gen_sse2_comi_round (rtx, rtx, rtx);
extern rtx gen_sse2_ucomi (rtx, rtx);
extern rtx gen_sse2_ucomi_round (rtx, rtx, rtx);
extern rtx gen_avx_andnotv8sf3 (rtx, rtx, rtx);
extern rtx gen_avx_andnotv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_andnotv4sf3 (rtx, rtx, rtx);
extern rtx gen_sse_andnotv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_andnotv4df3 (rtx, rtx, rtx);
extern rtx gen_avx_andnotv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_andnotv2df3 (rtx, rtx, rtx);
extern rtx gen_sse2_andnotv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv16sf3 (rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv8df3 (rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmadd_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmadd_v16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmadd_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmadd_v8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmadd_v8sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmadd_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmadd_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmadd_v4sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmadd_v8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmadd_v8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmadd_v4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmadd_v4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmadd_v4df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmadd_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmadd_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmadd_v2df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmadd_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmadd_v8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmadd_v8sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fmadd_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmadd_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmadd_v4sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmadd_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4df_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmadd_v4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmadd_v4df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fmadd_v2df_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmadd_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmadd_v2df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmadd_v16sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v16sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v8sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v8sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v8df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v8df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsub_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsub_v16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsub_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsub_v8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsub_v8sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmsub_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsub_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsub_v4sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmsub_v8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsub_v8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsub_v4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsub_v4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsub_v4df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmsub_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsub_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsub_v2df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmsub_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v16sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v16sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v8sf_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmsub_v8sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmsub_v8sf_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fmsub_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmsub_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmsub_v4sf_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmsub_v8df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v8df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4df_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmsub_v4df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmsub_v4df_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fmsub_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fmsub_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fmsub_v2df_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmadd_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmadd_v16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmadd_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmadd_v8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmadd_v8sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmadd_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmadd_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmadd_v4sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmadd_v8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmadd_v8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmadd_v4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmadd_v4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmadd_v4df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmadd_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmadd_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmadd_v2df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmadd_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v8sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fnmadd_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v4sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmadd_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v4df_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v4df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fnmadd_v2df_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v2df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmadd_v16sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v16sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v8sf_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v8sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v8sf_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fnmadd_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v4sf_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmadd_v8df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v8df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v4df_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v4df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v4df_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fnmadd_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmadd_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmadd_v2df_mask3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmsub_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmsub_v16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmsub_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmsub_v8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmsub_v8sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmsub_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmsub_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmsub_v4sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmsub_v8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmsub_v8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fnmsub_v4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmsub_v4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmsub_v4df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fnmsub_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fnmsub_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fnmsub_v2df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmsub_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmsub_v8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmsub_v8sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fnmsub_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmsub_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmsub_v4sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmsub_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4df_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmsub_v4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmsub_v4df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512vl_fnmsub_v2df_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512vl_fnmsub_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512vl_fnmsub_v2df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fnmsub_v16sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v16sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v8sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v8sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v8df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v8df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmaddsub_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmaddsub_v16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmaddsub_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmaddsub_v8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmaddsub_v8sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmaddsub_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmaddsub_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmaddsub_v4sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmaddsub_v8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmaddsub_v8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmaddsub_v4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmaddsub_v4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmaddsub_v4df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmaddsub_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmaddsub_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmaddsub_v2df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmaddsub_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v16sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v16sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v8sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v8sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v8df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v8df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsubadd_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsubadd_v16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsubadd_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsubadd_v8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsubadd_v8sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmsubadd_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsubadd_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsubadd_v4sf_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmsubadd_v8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsubadd_v8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma_fmsubadd_v4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsubadd_v4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsubadd_v4df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fma_fmsubadd_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_fma_fmsubadd_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fma_fmsubadd_v2df_maskz_1_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512f_fmsubadd_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v16sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v16sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v8sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v8sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v8df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsubadd_v8df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v4df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsubadd_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmsub_v4sf_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmsub_v4sf_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmsub_v2df_mask3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmsub_v2df_mask3_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_cvtpi2ps (rtx, rtx, rtx);
extern rtx gen_sse_cvtps2pi (rtx, rtx);
extern rtx gen_sse_cvttps2pi (rtx, rtx);
extern rtx gen_sse_cvtsi2ss (rtx, rtx, rtx);
extern rtx gen_sse_cvtsi2ss_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_cvtsi2ssq (rtx, rtx, rtx);
extern rtx gen_sse_cvtsi2ssq_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse_cvtss2si (rtx, rtx);
extern rtx gen_sse_cvtss2si_round (rtx, rtx, rtx);
extern rtx gen_sse_cvtss2siq (rtx, rtx);
extern rtx gen_sse_cvtss2siq_round (rtx, rtx, rtx);
extern rtx gen_sse_cvtss2si_2 (rtx, rtx);
extern rtx gen_sse_cvtss2siq_2 (rtx, rtx);
extern rtx gen_sse_cvttss2si (rtx, rtx);
extern rtx gen_sse_cvttss2si_round (rtx, rtx, rtx);
extern rtx gen_sse_cvttss2siq (rtx, rtx);
extern rtx gen_sse_cvttss2siq_round (rtx, rtx, rtx);
extern rtx gen_cvtusi2ss32 (rtx, rtx, rtx);
extern rtx gen_cvtusi2ss32_round (rtx, rtx, rtx, rtx);
extern rtx gen_cvtusi2sd32 (rtx, rtx, rtx);
static inline rtx gen_cvtusi2sd32_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_cvtusi2sd32_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_cvtusi2ss64 (rtx, rtx, rtx);
extern rtx gen_cvtusi2ss64_round (rtx, rtx, rtx, rtx);
extern rtx gen_cvtusi2sd64 (rtx, rtx, rtx);
extern rtx gen_cvtusi2sd64_round (rtx, rtx, rtx, rtx);
extern rtx gen_floatv16siv16sf2 (rtx, rtx);
extern rtx gen_floatv16siv16sf2_round (rtx, rtx, rtx);
extern rtx gen_floatv16siv16sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv16siv16sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatv8siv8sf2 (rtx, rtx);
static inline rtx gen_floatv8siv8sf2_round (rtx, rtx, rtx);
static inline rtx
gen_floatv8siv8sf2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_floatv8siv8sf2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_floatv8siv8sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_floatv8siv8sf2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_floatv4siv4sf2 (rtx, rtx);
static inline rtx gen_floatv4siv4sf2_round (rtx, rtx, rtx);
static inline rtx
gen_floatv4siv4sf2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_floatv4siv4sf2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_floatv4siv4sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_floatv4siv4sf2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ufloatv16siv16sf2 (rtx, rtx);
extern rtx gen_ufloatv16siv16sf2_round (rtx, rtx, rtx);
extern rtx gen_ufloatv16siv16sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv16siv16sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv8siv8sf2 (rtx, rtx);
extern rtx gen_ufloatv8siv8sf2_round (rtx, rtx, rtx);
extern rtx gen_ufloatv8siv8sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv8siv8sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv4siv4sf2 (rtx, rtx);
extern rtx gen_ufloatv4siv4sf2_round (rtx, rtx, rtx);
extern rtx gen_ufloatv4siv4sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv4siv4sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_fix_notruncv8sfv8si (rtx, rtx);
extern rtx gen_avx_fix_notruncv8sfv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_fix_notruncv4sfv4si (rtx, rtx);
extern rtx gen_sse2_fix_notruncv4sfv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fix_notruncv16sfv16si (rtx, rtx);
extern rtx gen_avx512f_fix_notruncv16sfv16si_round (rtx, rtx, rtx);
extern rtx gen_avx512f_fix_notruncv16sfv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fix_notruncv16sfv16si_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ufix_notruncv16sfv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ufix_notruncv16sfv16si_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ufix_notruncv8sfv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ufix_notruncv8sfv8si_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ufix_notruncv4sfv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ufix_notruncv4sfv4si_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_cvtps2qqv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_cvtps2qqv8di_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_cvtps2qqv4di_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_cvtps2qqv4di_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_cvtps2qqv4di_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_cvtps2qqv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_cvtps2uqqv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_cvtps2uqqv8di_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_cvtps2uqqv4di_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_cvtps2uqqv4di_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_cvtps2uqqv4di_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_cvtps2uqqv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv16sfv16si2 (rtx, rtx);
extern rtx gen_fix_truncv16sfv16si2_round (rtx, rtx, rtx);
extern rtx gen_fix_truncv16sfv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv16sfv16si2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufix_truncv16sfv16si2 (rtx, rtx);
extern rtx gen_ufix_truncv16sfv16si2_round (rtx, rtx, rtx);
extern rtx gen_ufix_truncv16sfv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_truncv16sfv16si2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv8sfv8si2 (rtx, rtx);
extern rtx gen_fix_truncv8sfv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv4sfv4si2 (rtx, rtx);
extern rtx gen_fix_truncv4sfv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_cvtpi2pd (rtx, rtx);
extern rtx gen_floatunsv2siv2df2 (rtx, rtx);
extern rtx gen_sse2_cvtpd2pi (rtx, rtx);
extern rtx gen_sse2_cvttpd2pi (rtx, rtx);
extern rtx gen_fixuns_truncv2dfv2si2 (rtx, rtx);
extern rtx gen_sse2_cvtsi2sd (rtx, rtx, rtx);
extern rtx gen_sse2_cvtsi2sdq (rtx, rtx, rtx);
extern rtx gen_sse2_cvtsi2sdq_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtss2usi (rtx, rtx);
extern rtx gen_avx512f_vcvtss2usi_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtss2usiq (rtx, rtx);
extern rtx gen_avx512f_vcvtss2usiq_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvttss2usi (rtx, rtx);
extern rtx gen_avx512f_vcvttss2usi_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvttss2usiq (rtx, rtx);
extern rtx gen_avx512f_vcvttss2usiq_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtsd2usi (rtx, rtx);
extern rtx gen_avx512f_vcvtsd2usi_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtsd2usiq (rtx, rtx);
extern rtx gen_avx512f_vcvtsd2usiq_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvttsd2usi (rtx, rtx);
extern rtx gen_avx512f_vcvttsd2usi_round (rtx, rtx, rtx);
extern rtx gen_avx512f_vcvttsd2usiq (rtx, rtx);
extern rtx gen_avx512f_vcvttsd2usiq_round (rtx, rtx, rtx);
extern rtx gen_sse2_cvtsd2si (rtx, rtx);
extern rtx gen_sse2_cvtsd2si_round (rtx, rtx, rtx);
extern rtx gen_sse2_cvtsd2siq (rtx, rtx);
extern rtx gen_sse2_cvtsd2siq_round (rtx, rtx, rtx);
extern rtx gen_sse2_cvtsd2si_2 (rtx, rtx);
extern rtx gen_sse2_cvtsd2siq_2 (rtx, rtx);
extern rtx gen_sse2_cvttsd2si (rtx, rtx);
extern rtx gen_sse2_cvttsd2si_round (rtx, rtx, rtx);
extern rtx gen_sse2_cvttsd2siq (rtx, rtx);
extern rtx gen_sse2_cvttsd2siq_round (rtx, rtx, rtx);
extern rtx gen_floatv8siv8df2 (rtx, rtx);
extern rtx gen_floatv8siv8df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv4siv4df2 (rtx, rtx);
extern rtx gen_floatv4siv4df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv8div8df2 (rtx, rtx);
extern rtx gen_floatv8div8df2_round (rtx, rtx, rtx);
extern rtx gen_floatv8div8df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv8div8df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv8div8df2 (rtx, rtx);
extern rtx gen_floatunsv8div8df2_round (rtx, rtx, rtx);
extern rtx gen_floatunsv8div8df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv8div8df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatv4div4df2 (rtx, rtx);
extern rtx gen_floatv4div4df2_round (rtx, rtx, rtx);
extern rtx gen_floatv4div4df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv4div4df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv4div4df2 (rtx, rtx);
extern rtx gen_floatunsv4div4df2_round (rtx, rtx, rtx);
extern rtx gen_floatunsv4div4df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv4div4df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatv2div2df2 (rtx, rtx);
extern rtx gen_floatv2div2df2_round (rtx, rtx, rtx);
extern rtx gen_floatv2div2df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv2div2df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv2div2df2 (rtx, rtx);
extern rtx gen_floatunsv2div2df2_round (rtx, rtx, rtx);
extern rtx gen_floatunsv2div2df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv2div2df2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatv8div8sf2 (rtx, rtx);
extern rtx gen_floatv8div8sf2_round (rtx, rtx, rtx);
extern rtx gen_floatv8div8sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatv8div8sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv8div8sf2 (rtx, rtx);
extern rtx gen_floatunsv8div8sf2_round (rtx, rtx, rtx);
extern rtx gen_floatunsv8div8sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv8div8sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_floatv4div4sf2 (rtx, rtx);
static inline rtx gen_floatv4div4sf2_round (rtx, rtx, rtx);
static inline rtx
gen_floatv4div4sf2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_floatv4div4sf2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_floatv4div4sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_floatv4div4sf2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_floatunsv4div4sf2 (rtx, rtx);
static inline rtx gen_floatunsv4div4sf2_round (rtx, rtx, rtx);
static inline rtx
gen_floatunsv4div4sf2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_floatunsv4div4sf2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_floatunsv4div4sf2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_floatunsv4div4sf2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ufloatv8siv8df2 (rtx, rtx);
extern rtx gen_ufloatv8siv8df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv4siv4df2 (rtx, rtx);
extern rtx gen_ufloatv4siv4df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufloatv2siv2df2 (rtx, rtx);
extern rtx gen_ufloatv2siv2df2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtdq2pd512_2 (rtx, rtx);
extern rtx gen_avx_cvtdq2pd256_2 (rtx, rtx);
extern rtx gen_sse2_cvtdq2pd (rtx, rtx);
extern rtx gen_sse2_cvtdq2pd_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtpd2dq512 (rtx, rtx);
extern rtx gen_avx512f_cvtpd2dq512_round (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtpd2dq512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtpd2dq512_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_cvtpd2dq256 (rtx, rtx);
extern rtx gen_avx_cvtpd2dq256_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_cvtpd2dq (rtx, rtx);
extern rtx gen_sse2_cvtpd2dq_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8si2 (rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8si2_round (rtx, rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8si2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv4dfv4si2 (rtx, rtx);
extern rtx gen_ufix_notruncv4dfv4si2_round (rtx, rtx, rtx);
extern rtx gen_ufix_notruncv4dfv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv4dfv4si2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv2dfv2si2 (rtx, rtx);
extern rtx gen_ufix_notruncv2dfv2si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv8dfv8si2 (rtx, rtx);
extern rtx gen_fix_truncv8dfv8si2_round (rtx, rtx, rtx);
extern rtx gen_fix_truncv8dfv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv8dfv8si2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8si2 (rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8si2_round (rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8si2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufix_truncv2dfv2si2 (rtx, rtx);
extern rtx gen_ufix_truncv2dfv2si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv4dfv4si2 (rtx, rtx);
extern rtx gen_fix_truncv4dfv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_truncv4dfv4si2 (rtx, rtx);
extern rtx gen_ufix_truncv4dfv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv8dfv8di2 (rtx, rtx);
extern rtx gen_fix_truncv8dfv8di2_round (rtx, rtx, rtx);
extern rtx gen_fix_truncv8dfv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv8dfv8di2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8di2 (rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8di2_round (rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8dfv8di2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv4dfv4di2 (rtx, rtx);
static inline rtx gen_fix_truncv4dfv4di2_round (rtx, rtx, rtx);
static inline rtx
gen_fix_truncv4dfv4di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_truncv4dfv4di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fix_truncv4dfv4di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fix_truncv4dfv4di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fixuns_truncv4dfv4di2 (rtx, rtx);
static inline rtx gen_fixuns_truncv4dfv4di2_round (rtx, rtx, rtx);
static inline rtx
gen_fixuns_truncv4dfv4di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fixuns_truncv4dfv4di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fixuns_truncv4dfv4di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fixuns_truncv4dfv4di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_truncv2dfv2di2 (rtx, rtx);
static inline rtx gen_fix_truncv2dfv2di2_round (rtx, rtx, rtx);
static inline rtx
gen_fix_truncv2dfv2di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_truncv2dfv2di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fix_truncv2dfv2di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fix_truncv2dfv2di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fixuns_truncv2dfv2di2 (rtx, rtx);
static inline rtx gen_fixuns_truncv2dfv2di2_round (rtx, rtx, rtx);
static inline rtx
gen_fixuns_truncv2dfv2di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fixuns_truncv2dfv2di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fixuns_truncv2dfv2di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fixuns_truncv2dfv2di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_notruncv8dfv8di2 (rtx, rtx);
extern rtx gen_fix_notruncv8dfv8di2_round (rtx, rtx, rtx);
extern rtx gen_fix_notruncv8dfv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_notruncv8dfv8di2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fix_notruncv4dfv4di2 (rtx, rtx);
static inline rtx gen_fix_notruncv4dfv4di2_round (rtx, rtx, rtx);
static inline rtx
gen_fix_notruncv4dfv4di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_notruncv4dfv4di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fix_notruncv4dfv4di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fix_notruncv4dfv4di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_notruncv2dfv2di2 (rtx, rtx);
static inline rtx gen_fix_notruncv2dfv2di2_round (rtx, rtx, rtx);
static inline rtx
gen_fix_notruncv2dfv2di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_notruncv2dfv2di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fix_notruncv2dfv2di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fix_notruncv2dfv2di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ufix_notruncv8dfv8di2 (rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8di2_round (rtx, rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv8dfv8di2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ufix_notruncv4dfv4di2 (rtx, rtx);
static inline rtx gen_ufix_notruncv4dfv4di2_round (rtx, rtx, rtx);
static inline rtx
gen_ufix_notruncv4dfv4di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ufix_notruncv4dfv4di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_ufix_notruncv4dfv4di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ufix_notruncv4dfv4di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ufix_notruncv2dfv2di2 (rtx, rtx);
static inline rtx gen_ufix_notruncv2dfv2di2_round (rtx, rtx, rtx);
static inline rtx
gen_ufix_notruncv2dfv2di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_ufix_notruncv2dfv2di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_ufix_notruncv2dfv2di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_ufix_notruncv2dfv2di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_truncv8sfv8di2 (rtx, rtx);
extern rtx gen_fix_truncv8sfv8di2_round (rtx, rtx, rtx);
extern rtx gen_fix_truncv8sfv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv8sfv8di2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8sfv8di2 (rtx, rtx);
extern rtx gen_fixuns_truncv8sfv8di2_round (rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8sfv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_fixuns_truncv8sfv8di2_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fix_truncv4sfv4di2 (rtx, rtx);
static inline rtx gen_fix_truncv4sfv4di2_round (rtx, rtx, rtx);
static inline rtx
gen_fix_truncv4sfv4di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fix_truncv4sfv4di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fix_truncv4sfv4di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fix_truncv4sfv4di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fixuns_truncv4sfv4di2 (rtx, rtx);
static inline rtx gen_fixuns_truncv4sfv4di2_round (rtx, rtx, rtx);
static inline rtx
gen_fixuns_truncv4sfv4di2_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_fixuns_truncv4sfv4di2_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_fixuns_truncv4sfv4di2_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_fixuns_truncv4sfv4di2_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_fix_truncv2sfv2di2 (rtx, rtx);
extern rtx gen_avx512dq_fix_truncv2sfv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fixuns_truncv2sfv2di2 (rtx, rtx);
extern rtx gen_avx512dq_fixuns_truncv2sfv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_truncv8sfv8si2 (rtx, rtx);
extern rtx gen_ufix_truncv8sfv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ufix_truncv4sfv4si2 (rtx, rtx);
extern rtx gen_ufix_truncv4sfv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_cvttpd2dq (rtx, rtx);
extern rtx gen_sse2_cvttpd2dq_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_cvtsd2ss (rtx, rtx, rtx);
extern rtx gen_sse2_cvtsd2ss_round (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_cvtss2sd (rtx, rtx, rtx);
extern rtx gen_sse2_cvtss2sd_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtpd2ps512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtpd2ps512_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_cvtpd2ps256 (rtx, rtx);
extern rtx gen_avx_cvtpd2ps256_mask (rtx, rtx, rtx, rtx);
extern rtx gen_truncv2dfv2sf2 (rtx, rtx);
extern rtx gen_avx512f_cvtps2pd512 (rtx, rtx);
extern rtx gen_avx512f_cvtps2pd512_round (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtps2pd512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtps2pd512_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_cvtps2pd256 (rtx, rtx);
static inline rtx gen_avx_cvtps2pd256_round (rtx, rtx, rtx);
static inline rtx
gen_avx_cvtps2pd256_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx_cvtps2pd256_mask (rtx, rtx, rtx, rtx);
static inline rtx gen_avx_cvtps2pd256_mask_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx_cvtps2pd256_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_vec_unpacks_lo_v16sf (rtx, rtx);
extern rtx gen_avx512bw_cvtb2maskv64qi (rtx, rtx);
extern rtx gen_avx512vl_cvtb2maskv16qi (rtx, rtx);
extern rtx gen_avx512vl_cvtb2maskv32qi (rtx, rtx);
extern rtx gen_avx512bw_cvtw2maskv32hi (rtx, rtx);
extern rtx gen_avx512vl_cvtw2maskv16hi (rtx, rtx);
extern rtx gen_avx512vl_cvtw2maskv8hi (rtx, rtx);
extern rtx gen_avx512f_cvtd2maskv16si (rtx, rtx);
extern rtx gen_avx512vl_cvtd2maskv8si (rtx, rtx);
extern rtx gen_avx512vl_cvtd2maskv4si (rtx, rtx);
extern rtx gen_avx512f_cvtq2maskv8di (rtx, rtx);
extern rtx gen_avx512vl_cvtq2maskv4di (rtx, rtx);
extern rtx gen_avx512vl_cvtq2maskv2di (rtx, rtx);
extern rtx gen_sse2_cvtps2pd (rtx, rtx);
extern rtx gen_sse2_cvtps2pd_mask (rtx, rtx, rtx, rtx);
extern rtx gen_extendv2sfv2df2 (rtx, rtx);
extern rtx gen_sse_movhlps (rtx, rtx, rtx);
extern rtx gen_sse_movlhps (rtx, rtx, rtx);
extern rtx gen_avx512f_unpckhps512_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_unpckhps256 (rtx, rtx, rtx);
extern rtx gen_avx_unpckhps256_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv4sf (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_unpcklps512_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_unpcklps256 (rtx, rtx, rtx);
extern rtx gen_avx_unpcklps256_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_unpcklps128_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv4sf (rtx, rtx, rtx);
extern rtx gen_avx_movshdup256 (rtx, rtx);
extern rtx gen_avx_movshdup256_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse3_movshdup (rtx, rtx);
extern rtx gen_sse3_movshdup_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_movshdup512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx_movsldup256 (rtx, rtx);
extern rtx gen_avx_movsldup256_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse3_movsldup (rtx, rtx);
extern rtx gen_sse3_movsldup_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_movsldup512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufps256_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufps256_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_shufps_v4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_shufps_v4si (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_shufps_v4sf (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_storehps (rtx, rtx);
extern rtx gen_sse_loadhps (rtx, rtx, rtx);
extern rtx gen_sse_storelps (rtx, rtx);
extern rtx gen_sse_loadlps (rtx, rtx, rtx);
extern rtx gen_sse_movss (rtx, rtx, rtx);
extern rtx gen_avx2_vec_dupv8sf (rtx, rtx);
extern rtx gen_avx2_vec_dupv4sf (rtx, rtx);
extern rtx gen_avx2_vec_dupv8sf_1 (rtx, rtx);
extern rtx gen_avx512f_vec_dupv16sf_1 (rtx, rtx);
extern rtx gen_avx512f_vec_dupv8df_1 (rtx, rtx);
extern rtx gen_vec_setv4si_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv4sf_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv8si_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv8sf_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv16si_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv16sf_0 (rtx, rtx, rtx);
extern rtx gen_sse4_1_insertps (rtx, rtx, rtx, rtx);
extern rtx gen_vec_setv2df_0 (rtx, rtx, rtx);
extern rtx gen_avx512dq_vextractf64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vextracti64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vextractf32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vextracti32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v8df (rtx, rtx);
extern rtx gen_vec_extract_lo_v8di (rtx, rtx);
extern rtx gen_vec_extract_hi_v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v8df (rtx, rtx);
extern rtx gen_vec_extract_hi_v8di (rtx, rtx);
extern rtx gen_vec_extract_hi_v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v16sf (rtx, rtx);
extern rtx gen_vec_extract_hi_v16si (rtx, rtx);
extern rtx gen_vec_extract_lo_v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v16sf (rtx, rtx);
extern rtx gen_vec_extract_lo_v16si (rtx, rtx);
extern rtx gen_vec_extract_lo_v4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v4di (rtx, rtx);
extern rtx gen_vec_extract_lo_v4df (rtx, rtx);
extern rtx gen_vec_extract_hi_v4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v4di (rtx, rtx);
extern rtx gen_vec_extract_hi_v4df (rtx, rtx);
extern rtx gen_vec_extract_lo_v8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_lo_v8si (rtx, rtx);
extern rtx gen_vec_extract_lo_v8sf (rtx, rtx);
extern rtx gen_vec_extract_hi_v8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_extract_hi_v8si (rtx, rtx);
extern rtx gen_vec_extract_hi_v8sf (rtx, rtx);
extern rtx gen_vec_extract_lo_v32hi (rtx, rtx);
extern rtx gen_vec_extract_hi_v32hi (rtx, rtx);
extern rtx gen_vec_extract_lo_v16hi (rtx, rtx);
extern rtx gen_vec_extract_hi_v16hi (rtx, rtx);
extern rtx gen_vec_extract_lo_v64qi (rtx, rtx);
extern rtx gen_vec_extract_hi_v64qi (rtx, rtx);
extern rtx gen_vec_extract_lo_v32qi (rtx, rtx);
extern rtx gen_vec_extract_hi_v32qi (rtx, rtx);
extern rtx gen_avx512f_unpckhpd512_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_unpckhpd256 (rtx, rtx, rtx);
extern rtx gen_avx_unpckhpd256_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_unpckhpd128_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_unpcklpd128_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv4sf (rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv2df (rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmscalefv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv16sf (rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv16sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv8sf (rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv8sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4sf (rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv8df (rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv8df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scalefv8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4df (rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv2df (rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scalefv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv16si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv8si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv8di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv8di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv2di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv2di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv16si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv8si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv8di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv2di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getexpv16sf (rtx, rtx);
extern rtx gen_avx512f_getexpv16sf_round (rtx, rtx, rtx);
extern rtx gen_avx512f_getexpv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getexpv16sf_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv8sf (rtx, rtx);
extern rtx gen_avx512vl_getexpv8sf_round (rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv8sf_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv4sf (rtx, rtx);
extern rtx gen_avx512vl_getexpv4sf_round (rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv4sf_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getexpv8df (rtx, rtx);
extern rtx gen_avx512f_getexpv8df_round (rtx, rtx, rtx);
extern rtx gen_avx512f_getexpv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getexpv8df_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv4df (rtx, rtx);
extern rtx gen_avx512vl_getexpv4df_round (rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv4df_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv2df (rtx, rtx);
extern rtx gen_avx512vl_getexpv2df_round (rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getexpv2df_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv4sf (rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv2df (rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sgetexpv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_alignv16si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_alignv8si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_alignv4si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_alignv8di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_alignv4di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_alignv2di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_maskz_1_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev16sf (rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev16sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev8sf (rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev8sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4sf (rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev8df (rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev8df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4df (rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev2df (rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rndscalev2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev4sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev2df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rndscalev2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shufps512_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shufps512_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shufpd512_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shufpd512_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufpd256_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufpd256_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_shufpd_v2df_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv4di (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_interleave_highv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv2di (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv4di (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_interleave_lowv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv2di (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_shufpd_v2di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_shufpd_v2df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_storehpd (rtx, rtx);
extern rtx gen_sse2_storelpd (rtx, rtx);
extern rtx gen_sse2_loadhpd (rtx, rtx, rtx);
extern rtx gen_sse2_loadlpd (rtx, rtx, rtx);
extern rtx gen_sse2_movsd (rtx, rtx, rtx);
extern rtx gen_vec_dupv2df (rtx, rtx);
extern rtx gen_vec_dupv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_concatv2df (rtx, rtx, rtx);
extern rtx gen_vec_setv8df_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv4df_0 (rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev16siv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev16siv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev16siv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev16siv16hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev16siv16hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev16siv16hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev8div8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev8div8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ss_truncatev32hiv32qi2 (rtx, rtx);
extern rtx gen_avx512bw_truncatev32hiv32qi2 (rtx, rtx);
extern rtx gen_avx512bw_us_truncatev32hiv32qi2 (rtx, rtx);
extern rtx gen_avx512bw_ss_truncatev32hiv32qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_truncatev32hiv32qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_us_truncatev32hiv32qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8siv8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8siv8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8siv8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev16hiv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev16hiv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev16hiv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8siv8qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8siv8qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8siv8qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4siv4qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4siv4qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4siv4qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8hiv8qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8hiv8qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8hiv8qi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4siv4qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4siv4qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4siv4qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4siv4qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4siv4qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4siv4qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8hiv8qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8hiv8qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8hiv8qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8siv8qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8siv8qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8siv8qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8hiv8qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8hiv8qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8hiv8qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8siv8qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8siv8qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8siv8qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4siv4hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4siv4hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4siv4hi2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4siv4hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4siv4hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4siv4hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4siv4hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4siv4hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4siv4hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2hi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2si2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2si2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2si2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev2div2si2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev2div2si2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev2div2si2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div16qi2 (rtx, rtx);
extern rtx gen_avx512f_truncatev8div16qi2 (rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div16qi2 (rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev8div16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div16qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev8div16qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div16qi2_mask_store_2 (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddwd512v32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddwd512v32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddwd512v16hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddwd512v16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddwd512v8hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddwd512v8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_mulv8di3 (rtx, rtx, rtx);
extern rtx gen_avx512dq_mulv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_mulv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512dq_mulv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_mulv2di3 (rtx, rtx, rtx);
extern rtx gen_avx512dq_mulv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv16hi3 (rtx, rtx, rtx);
extern rtx gen_ashrv8hi3 (rtx, rtx, rtx);
extern rtx gen_ashrv8si3 (rtx, rtx, rtx);
extern rtx gen_ashrv4si3 (rtx, rtx, rtx);
extern rtx gen_ashrv32hi3 (rtx, rtx, rtx);
extern rtx gen_ashrv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv4di3 (rtx, rtx, rtx);
extern rtx gen_ashrv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv16si3 (rtx, rtx, rtx);
extern rtx gen_ashrv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashrv8di3 (rtx, rtx, rtx);
extern rtx gen_ashrv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv16hi3 (rtx, rtx, rtx);
extern rtx gen_lshrv16hi3 (rtx, rtx, rtx);
extern rtx gen_ashlv8hi3 (rtx, rtx, rtx);
extern rtx gen_lshrv8hi3 (rtx, rtx, rtx);
extern rtx gen_ashlv8si3 (rtx, rtx, rtx);
extern rtx gen_lshrv8si3 (rtx, rtx, rtx);
extern rtx gen_ashlv4si3 (rtx, rtx, rtx);
extern rtx gen_lshrv4si3 (rtx, rtx, rtx);
extern rtx gen_ashlv4di3 (rtx, rtx, rtx);
extern rtx gen_lshrv4di3 (rtx, rtx, rtx);
extern rtx gen_ashlv2di3 (rtx, rtx, rtx);
extern rtx gen_lshrv2di3 (rtx, rtx, rtx);
extern rtx gen_ashlv32hi3 (rtx, rtx, rtx);
extern rtx gen_ashlv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv32hi3 (rtx, rtx, rtx);
extern rtx gen_lshrv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv16si3 (rtx, rtx, rtx);
extern rtx gen_ashlv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv16si3 (rtx, rtx, rtx);
extern rtx gen_lshrv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ashlv8di3 (rtx, rtx, rtx);
extern rtx gen_ashlv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_lshrv8di3 (rtx, rtx, rtx);
extern rtx gen_lshrv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ashlv4ti3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_lshrv4ti3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_ashlv2ti3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_lshrv2ti3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_ashlv1ti3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_lshrv1ti3 (rtx, rtx, rtx);
extern rtx gen_avx2_ashlv2ti3 (rtx, rtx, rtx);
extern rtx gen_avx2_lshrv2ti3 (rtx, rtx, rtx);
extern rtx gen_sse2_ashlv1ti3 (rtx, rtx, rtx);
extern rtx gen_sse2_lshrv1ti3 (rtx, rtx, rtx);
extern rtx gen_avx512f_rolvv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_rolvv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rorvv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_rorvv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv8si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv8si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv4si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv4si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rolvv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_rolvv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rorvv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_rorvv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv4di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv4di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv2di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolvv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv2di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorvv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rolv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_rolv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rorv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_rorv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv8si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv8si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv4si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv4si (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rolv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_rolv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_rorv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_rorv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv4di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv4di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv2di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rolv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv2di (rtx, rtx, rtx);
extern rtx gen_avx512vl_rorv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv64qi3_1 (rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv64qi3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16qi3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16qi3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv32qi3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv32qi3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv32hi3_1 (rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv32hi3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16hi3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16hi3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8hi3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8hi3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_eqv16si3_1 (rtx, rtx, rtx);
extern rtx gen_avx512f_eqv16si3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8si3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8si3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4si3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4si3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_eqv8di3_1 (rtx, rtx, rtx);
extern rtx gen_avx512f_eqv8di3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4di3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4di3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv2di3_1 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv2di3_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_gtv2di3 (rtx, rtx, rtx);
extern rtx gen_avx2_gtv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_gtv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_gtv8si3 (rtx, rtx, rtx);
extern rtx gen_avx2_gtv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512f_gtv16si3 (rtx, rtx, rtx);
extern rtx gen_avx512f_gtv16si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv8si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv8si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv4si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv4si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gtv8di3 (rtx, rtx, rtx);
extern rtx gen_avx512f_gtv8di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv4di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv2di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv2di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_gtv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_gtv64qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv16qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv16qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv32qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_gtv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_gtv32hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv16hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_gtv8hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_gtv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_gtv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_gtv4si3 (rtx, rtx, rtx);
extern rtx gen_one_cmplv16si2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_one_cmplv8di2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_one_cmplv64qi2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_one_cmplv64qi2_mask(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
static inline rtx gen_one_cmplv32qi2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_one_cmplv32qi2_mask(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
static inline rtx gen_one_cmplv16qi2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_one_cmplv16qi2_mask(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
static inline rtx gen_one_cmplv32hi2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_one_cmplv32hi2_mask(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
static inline rtx gen_one_cmplv16hi2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_one_cmplv16hi2_mask(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
static inline rtx gen_one_cmplv8hi2_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_one_cmplv8hi2_mask(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_one_cmplv8si2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_one_cmplv4si2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_one_cmplv4di2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_one_cmplv2di2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_testmv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_testmv64qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv32qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv16qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv16qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_testmv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_testmv32hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv16hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv8hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_testmv16si3 (rtx, rtx, rtx);
extern rtx gen_avx512f_testmv16si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv8si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv8si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv4si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv4si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_testmv8di3 (rtx, rtx, rtx);
extern rtx gen_avx512f_testmv8di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv4di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv2di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testmv2di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_testnmv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_testnmv64qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv32qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv16qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv16qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_testnmv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_testnmv32hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv16hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv8hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_testnmv16si3 (rtx, rtx, rtx);
extern rtx gen_avx512f_testnmv16si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv8si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv8si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv4si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv4si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_testnmv8di3 (rtx, rtx, rtx);
extern rtx gen_avx512f_testnmv8di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv4di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv2di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_testnmv2di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_packsswb (rtx, rtx, rtx);
extern rtx gen_avx512bw_packsswb_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_packsswb (rtx, rtx, rtx);
extern rtx gen_avx2_packsswb_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_packsswb (rtx, rtx, rtx);
extern rtx gen_sse2_packsswb_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_packssdw (rtx, rtx, rtx);
extern rtx gen_avx512bw_packssdw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_packssdw (rtx, rtx, rtx);
extern rtx gen_avx2_packssdw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_packssdw (rtx, rtx, rtx);
extern rtx gen_sse2_packssdw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_packuswb (rtx, rtx, rtx);
extern rtx gen_avx512bw_packuswb_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_packuswb (rtx, rtx, rtx);
extern rtx gen_avx2_packuswb_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_packuswb (rtx, rtx, rtx);
extern rtx gen_sse2_packuswb_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_highv64qi (rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_highv64qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv32qi (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv32qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv16qi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv16qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_lowv64qi (rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_lowv64qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv32qi (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv32qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv16qi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv16qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_highv32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_highv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv16hi (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv8hi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_interleave_lowv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv16hi (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv8hi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv8si (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_highv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_interleave_highv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv4si (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv8si (rtx, rtx, rtx);
extern rtx gen_avx2_interleave_lowv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_interleave_lowv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv4si (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_pinsrb (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pinsrw (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_pinsrd (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_pinsrq (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vinsertf64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vinserti64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vinsertf32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vinserti32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v16sf (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v16si (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v16sf (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v16si (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8df (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8di (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8df (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8di (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_shuf_i64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_shuf_f64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_f64x2_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_f64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_i64x2_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_i64x2_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_shuf_i32x4_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_shuf_i32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_shuf_f32x4_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_shuf_f32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_f32x4_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_f32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_i32x4_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_i32x4_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_pshufd_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_pshufd_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshufd_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshufd_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshufd_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshufd_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_pshuflwv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshuflw_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshuflw_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshuflw_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshuflw_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_pshufhwv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshufhw_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshufhw_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshufhw_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshufhw_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_loadld (rtx, rtx, rtx);
extern rtx gen_vec_concatv2di (rtx, rtx, rtx);
extern rtx gen_vec_setv8di_0 (rtx, rtx, rtx);
extern rtx gen_vec_setv4di_0 (rtx, rtx, rtx);
extern rtx gen_avx512f_psadbw (rtx, rtx, rtx);
extern rtx gen_avx2_psadbw (rtx, rtx, rtx);
extern rtx gen_sse2_psadbw (rtx, rtx, rtx);
extern rtx gen_avx_movmskps256 (rtx, rtx);
extern rtx gen_sse_movmskps (rtx, rtx);
extern rtx gen_avx_movmskpd256 (rtx, rtx);
extern rtx gen_sse2_movmskpd (rtx, rtx);
extern rtx gen_avx2_pmovmskb (rtx, rtx);
extern rtx gen_sse2_pmovmskb (rtx, rtx);
extern rtx gen_sse_ldmxcsr (rtx);
extern rtx gen_sse_stmxcsr (rtx);
extern rtx gen_sse2_clflush (rtx);
extern rtx gen_sse3_mwait (rtx, rtx);
extern rtx gen_sse3_monitor_si (rtx, rtx, rtx);
extern rtx gen_sse3_monitor_di (rtx, rtx, rtx);
extern rtx gen_avx2_phaddwv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_phaddswv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_phsubwv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_phsubswv16hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phaddwv8hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phaddswv8hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phsubwv8hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phsubswv8hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phaddwv4hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phaddswv4hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phsubwv4hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phsubswv4hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_phadddv8si3 (rtx, rtx, rtx);
extern rtx gen_avx2_phsubdv8si3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phadddv4si3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phsubdv4si3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phadddv2si3 (rtx, rtx, rtx);
extern rtx gen_ssse3_phsubdv2si3 (rtx, rtx, rtx);
extern rtx gen_avx2_pmaddubsw256 (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddubsw512v8hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddubsw512v8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddubsw512v16hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddubsw512v16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddubsw512v32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_pmaddubsw512v32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_umulhrswv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_umulhrswv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_pmaddubsw128 (rtx, rtx, rtx);
extern rtx gen_ssse3_pmaddubsw (rtx, rtx, rtx);
extern rtx gen_avx512bw_pshufbv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_pshufbv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshufbv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_pshufbv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_pshufbv16qi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_pshufbv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_pshufbv8qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_psignv32qi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_psignv16qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_psignv16hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_psignv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_psignv8si3 (rtx, rtx, rtx);
extern rtx gen_ssse3_psignv4si3 (rtx, rtx, rtx);
extern rtx gen_ssse3_psignv8qi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_psignv4hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_psignv2si3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_palignrv64qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_palignrv32qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_palignrv16qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_palignrv4ti (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_palignrv2ti (rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_palignrti (rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_palignrdi (rtx, rtx, rtx, rtx);
extern rtx gen_absv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv64qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv16qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv32qi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv32hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv16hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_absv8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_absv8qi2 (rtx, rtx);
extern rtx gen_ssse3_absv4hi2 (rtx, rtx);
extern rtx gen_ssse3_absv2si2 (rtx, rtx);
extern rtx gen_absv8qi2 (rtx, rtx);
extern rtx gen_absv4hi2 (rtx, rtx);
extern rtx gen_absv2si2 (rtx, rtx);
extern rtx gen_sse4a_movntsf (rtx, rtx);
extern rtx gen_sse4a_movntdf (rtx, rtx);
extern rtx gen_sse4a_vmmovntv4sf (rtx, rtx);
extern rtx gen_sse4a_vmmovntv2df (rtx, rtx);
extern rtx gen_sse4a_extrqi (rtx, rtx, rtx, rtx);
extern rtx gen_sse4a_extrq (rtx, rtx, rtx);
extern rtx gen_sse4a_insertqi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4a_insertq (rtx, rtx, rtx);
extern rtx gen_avx_blendps256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_blendps (rtx, rtx, rtx, rtx);
extern rtx gen_avx_blendpd256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_blendpd (rtx, rtx, rtx, rtx);
extern rtx gen_avx_blendvps256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_blendvps (rtx, rtx, rtx, rtx);
extern rtx gen_avx_blendvpd256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_blendvpd (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_blendvss (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_blendvsd (rtx, rtx, rtx, rtx);
extern rtx gen_avx_dpps256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_dpps (rtx, rtx, rtx, rtx);
extern rtx gen_avx_dppd256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_dppd (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_movntdqa (rtx, rtx);
extern rtx gen_avx2_movntdqa (rtx, rtx);
extern rtx gen_sse4_1_movntdqa (rtx, rtx);
extern rtx gen_avx2_mpsadbw (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_mpsadbw (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_packusdw (rtx, rtx, rtx);
extern rtx gen_avx512bw_packusdw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_packusdw (rtx, rtx, rtx);
extern rtx gen_avx2_packusdw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_packusdw (rtx, rtx, rtx);
extern rtx gen_sse4_1_packusdw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pblendvb (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_pblendvb (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_pblendw (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pblenddv8si (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pblenddv4si (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_phminposuw (rtx, rtx);
extern rtx gen_avx2_sign_extendv16qiv16hi2 (rtx, rtx);
extern rtx gen_avx2_sign_extendv16qiv16hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_zero_extendv16qiv16hi2 (rtx, rtx);
extern rtx gen_avx2_zero_extendv16qiv16hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_sign_extendv32qiv32hi2 (rtx, rtx);
extern rtx gen_avx512bw_sign_extendv32qiv32hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_zero_extendv32qiv32hi2 (rtx, rtx);
extern rtx gen_avx512bw_zero_extendv32qiv32hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_sign_extendv8qiv8hi2 (rtx, rtx);
extern rtx gen_sse4_1_sign_extendv8qiv8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_zero_extendv8qiv8hi2 (rtx, rtx);
extern rtx gen_sse4_1_zero_extendv8qiv8hi2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sign_extendv16qiv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_zero_extendv16qiv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sign_extendv8qiv8si2 (rtx, rtx);
extern rtx gen_avx2_sign_extendv8qiv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_zero_extendv8qiv8si2 (rtx, rtx);
extern rtx gen_avx2_zero_extendv8qiv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_sign_extendv4qiv4si2 (rtx, rtx);
extern rtx gen_sse4_1_sign_extendv4qiv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_zero_extendv4qiv4si2 (rtx, rtx);
extern rtx gen_sse4_1_zero_extendv4qiv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sign_extendv16hiv16si2 (rtx, rtx);
extern rtx gen_avx512f_sign_extendv16hiv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_zero_extendv16hiv16si2 (rtx, rtx);
extern rtx gen_avx512f_zero_extendv16hiv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sign_extendv8hiv8si2 (rtx, rtx);
extern rtx gen_avx2_sign_extendv8hiv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_zero_extendv8hiv8si2 (rtx, rtx);
extern rtx gen_avx2_zero_extendv8hiv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_sign_extendv4hiv4si2 (rtx, rtx);
extern rtx gen_sse4_1_sign_extendv4hiv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_zero_extendv4hiv4si2 (rtx, rtx);
extern rtx gen_sse4_1_zero_extendv4hiv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sign_extendv8qiv8di2 (rtx, rtx);
extern rtx gen_avx512f_sign_extendv8qiv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_zero_extendv8qiv8di2 (rtx, rtx);
extern rtx gen_avx512f_zero_extendv8qiv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sign_extendv4qiv4di2 (rtx, rtx);
extern rtx gen_avx2_sign_extendv4qiv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_zero_extendv4qiv4di2 (rtx, rtx);
extern rtx gen_avx2_zero_extendv4qiv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_sign_extendv2qiv2di2 (rtx, rtx);
extern rtx gen_sse4_1_sign_extendv2qiv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_zero_extendv2qiv2di2 (rtx, rtx);
extern rtx gen_sse4_1_zero_extendv2qiv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sign_extendv8hiv8di2 (rtx, rtx);
extern rtx gen_avx512f_sign_extendv8hiv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_zero_extendv8hiv8di2 (rtx, rtx);
extern rtx gen_avx512f_zero_extendv8hiv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sign_extendv4hiv4di2 (rtx, rtx);
extern rtx gen_avx2_sign_extendv4hiv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_zero_extendv4hiv4di2 (rtx, rtx);
extern rtx gen_avx2_zero_extendv4hiv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_sign_extendv2hiv2di2 (rtx, rtx);
extern rtx gen_sse4_1_sign_extendv2hiv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_zero_extendv2hiv2di2 (rtx, rtx);
extern rtx gen_sse4_1_zero_extendv2hiv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sign_extendv8siv8di2 (rtx, rtx);
extern rtx gen_avx512f_sign_extendv8siv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_zero_extendv8siv8di2 (rtx, rtx);
extern rtx gen_avx512f_zero_extendv8siv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sign_extendv4siv4di2 (rtx, rtx);
extern rtx gen_avx2_sign_extendv4siv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_zero_extendv4siv4di2 (rtx, rtx);
extern rtx gen_avx2_zero_extendv4siv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_sign_extendv2siv2di2 (rtx, rtx);
extern rtx gen_sse4_1_sign_extendv2siv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_zero_extendv2siv2di2 (rtx, rtx);
extern rtx gen_sse4_1_zero_extendv2siv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vtestps256 (rtx, rtx);
extern rtx gen_avx_vtestps (rtx, rtx);
extern rtx gen_avx_vtestpd256 (rtx, rtx);
extern rtx gen_avx_vtestpd (rtx, rtx);
extern rtx gen_sse4_1_ptestv16qi (rtx, rtx);
extern rtx gen_sse4_1_ptestv8hi (rtx, rtx);
extern rtx gen_sse4_1_ptestv4si (rtx, rtx);
extern rtx gen_sse4_1_ptestv2di (rtx, rtx);
extern rtx gen_sse4_1_ptestv4sf (rtx, rtx);
extern rtx gen_sse4_1_ptestv2df (rtx, rtx);
extern rtx gen_avx_ptestv32qi (rtx, rtx);
extern rtx gen_avx_ptestv16hi (rtx, rtx);
extern rtx gen_avx_ptestv8si (rtx, rtx);
extern rtx gen_avx_ptestv4di (rtx, rtx);
extern rtx gen_avx_ptestv8sf (rtx, rtx);
extern rtx gen_avx_ptestv4df (rtx, rtx);
extern rtx gen_ptesttf2 (rtx, rtx);
extern rtx gen_avx_roundps256 (rtx, rtx, rtx);
extern rtx gen_sse4_1_roundps (rtx, rtx, rtx);
extern rtx gen_avx_roundpd256 (rtx, rtx, rtx);
extern rtx gen_sse4_1_roundpd (rtx, rtx, rtx);
extern rtx gen_sse4_1_roundss (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_roundsd (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpestr (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpestri (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpestrm (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpestr_cconly (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpistr (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpistri (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpistrm (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_2_pcmpistr_cconly (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_exp2v16sf (rtx, rtx);
extern rtx gen_avx512er_exp2v16sf_round (rtx, rtx, rtx);
extern rtx gen_avx512er_exp2v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_exp2v16sf_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_exp2v8df (rtx, rtx);
extern rtx gen_avx512er_exp2v8df_round (rtx, rtx, rtx);
extern rtx gen_avx512er_exp2v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_exp2v8df_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rcp28v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rcp28v16sf_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rcp28v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rcp28v8df_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_vmrcp28v4sf (rtx, rtx, rtx);
extern rtx gen_avx512er_vmrcp28v4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_vmrcp28v2df (rtx, rtx, rtx);
extern rtx gen_avx512er_vmrcp28v2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rsqrt28v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rsqrt28v16sf_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rsqrt28v8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_rsqrt28v8df_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_vmrsqrt28v4sf (rtx, rtx, rtx);
extern rtx gen_avx512er_vmrsqrt28v4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512er_vmrsqrt28v2df (rtx, rtx, rtx);
extern rtx gen_avx512er_vmrsqrt28v2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacsww (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacssww (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacsdd (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacssdd (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacsdql (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacssdql (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacsdqh (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacssdqh (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacswd (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmacsswd (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmadcswd (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pmadcsswd (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v32qi256 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v16qi (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v16hi256 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v8hi (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v8si256 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v4di256 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v2di (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v8sf256 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v4df256 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcmov_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_xop_phaddbw (rtx, rtx);
extern rtx gen_xop_phaddubw (rtx, rtx);
extern rtx gen_xop_phaddbd (rtx, rtx);
extern rtx gen_xop_phaddubd (rtx, rtx);
extern rtx gen_xop_phaddbq (rtx, rtx);
extern rtx gen_xop_phaddubq (rtx, rtx);
extern rtx gen_xop_phaddwd (rtx, rtx);
extern rtx gen_xop_phadduwd (rtx, rtx);
extern rtx gen_xop_phaddwq (rtx, rtx);
extern rtx gen_xop_phadduwq (rtx, rtx);
extern rtx gen_xop_phadddq (rtx, rtx);
extern rtx gen_xop_phaddudq (rtx, rtx);
extern rtx gen_xop_phsubbw (rtx, rtx);
extern rtx gen_xop_phsubwd (rtx, rtx);
extern rtx gen_xop_phsubdq (rtx, rtx);
extern rtx gen_xop_pperm (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pperm_pack_v2di_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pperm_pack_v4si_v8hi (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pperm_pack_v8hi_v16qi (rtx, rtx, rtx, rtx);
extern rtx gen_xop_rotlv16qi3 (rtx, rtx, rtx);
extern rtx gen_xop_rotlv8hi3 (rtx, rtx, rtx);
extern rtx gen_xop_rotlv4si3 (rtx, rtx, rtx);
extern rtx gen_xop_rotlv2di3 (rtx, rtx, rtx);
extern rtx gen_xop_rotrv16qi3 (rtx, rtx, rtx);
extern rtx gen_xop_rotrv8hi3 (rtx, rtx, rtx);
extern rtx gen_xop_rotrv4si3 (rtx, rtx, rtx);
extern rtx gen_xop_rotrv2di3 (rtx, rtx, rtx);
extern rtx gen_xop_vrotlv16qi3 (rtx, rtx, rtx);
extern rtx gen_xop_vrotlv8hi3 (rtx, rtx, rtx);
extern rtx gen_xop_vrotlv4si3 (rtx, rtx, rtx);
extern rtx gen_xop_vrotlv2di3 (rtx, rtx, rtx);
extern rtx gen_xop_shav16qi3 (rtx, rtx, rtx);
extern rtx gen_xop_shav8hi3 (rtx, rtx, rtx);
extern rtx gen_xop_shav4si3 (rtx, rtx, rtx);
extern rtx gen_xop_shav2di3 (rtx, rtx, rtx);
extern rtx gen_xop_shlv16qi3 (rtx, rtx, rtx);
extern rtx gen_xop_shlv8hi3 (rtx, rtx, rtx);
extern rtx gen_xop_shlv4si3 (rtx, rtx, rtx);
extern rtx gen_xop_shlv2di3 (rtx, rtx, rtx);
extern rtx gen_xop_frczsf2 (rtx, rtx);
extern rtx gen_xop_frczdf2 (rtx, rtx);
extern rtx gen_xop_frczv4sf2 (rtx, rtx);
extern rtx gen_xop_frczv2df2 (rtx, rtx);
extern rtx gen_xop_frczv8sf2 (rtx, rtx);
extern rtx gen_xop_frczv4df2 (rtx, rtx);
extern rtx gen_xop_maskcmpv16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmpv8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmpv4si3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmpv2di3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_unsv16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_unsv8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_unsv4si3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_unsv2di3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_uns2v16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_uns2v8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_uns2v4si3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_maskcmp_uns2v2di3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcom_tfv16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcom_tfv8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcom_tfv4si3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_pcom_tfv2di3 (rtx, rtx, rtx, rtx);
extern rtx gen_xop_vpermil2v8sf3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xop_vpermil2v4sf3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xop_vpermil2v4df3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xop_vpermil2v2df3 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_aesenc (rtx, rtx, rtx);
extern rtx gen_aesenclast (rtx, rtx, rtx);
extern rtx gen_aesdec (rtx, rtx, rtx);
extern rtx gen_aesdeclast (rtx, rtx, rtx);
extern rtx gen_aesimc (rtx, rtx);
extern rtx gen_aeskeygenassist (rtx, rtx, rtx);
extern rtx gen_pclmulqdq (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pbroadcastv16si (rtx, rtx);
extern rtx gen_avx2_pbroadcastv8di (rtx, rtx);
extern rtx gen_avx2_pbroadcastv64qi (rtx, rtx);
extern rtx gen_avx2_pbroadcastv32qi (rtx, rtx);
extern rtx gen_avx2_pbroadcastv16qi (rtx, rtx);
extern rtx gen_avx2_pbroadcastv32hi (rtx, rtx);
extern rtx gen_avx2_pbroadcastv16hi (rtx, rtx);
extern rtx gen_avx2_pbroadcastv8hi (rtx, rtx);
extern rtx gen_avx2_pbroadcastv8si (rtx, rtx);
extern rtx gen_avx2_pbroadcastv4si (rtx, rtx);
extern rtx gen_avx2_pbroadcastv4di (rtx, rtx);
extern rtx gen_avx2_pbroadcastv2di (rtx, rtx);
extern rtx gen_avx2_pbroadcastv32qi_1 (rtx, rtx);
extern rtx gen_avx2_pbroadcastv16hi_1 (rtx, rtx);
extern rtx gen_avx2_pbroadcastv8si_1 (rtx, rtx);
extern rtx gen_avx2_pbroadcastv4di_1 (rtx, rtx);
extern rtx gen_avx2_permvarv8si (rtx, rtx, rtx);
extern rtx gen_avx2_permvarv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permvarv8sf (rtx, rtx, rtx);
extern rtx gen_avx2_permvarv8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv16sf (rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv8df (rtx, rtx, rtx);
extern rtx gen_avx512f_permvarv8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permvarv4di (rtx, rtx, rtx);
extern rtx gen_avx2_permvarv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permvarv4df (rtx, rtx, rtx);
extern rtx gen_avx2_permvarv4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_permvarv64qi (rtx, rtx, rtx);
extern rtx gen_avx512bw_permvarv64qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv16qi (rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv16qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv32qi (rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv32qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv8hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv16hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_permvarv16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_permvarv32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_permvarv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permv4di_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permv4di_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permv4df_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permv4df_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permv8df_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permv8df_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permv8di_1 (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permv8di_1_mask (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permv2ti (rtx, rtx, rtx, rtx);
extern rtx gen_avx2_vec_dupv4df (rtx, rtx);
extern rtx gen_avx512f_vec_dupv16si_1 (rtx, rtx);
extern rtx gen_avx512f_vec_dupv8di_1 (rtx, rtx);
extern rtx gen_avx512bw_vec_dupv32hi_1 (rtx, rtx);
extern rtx gen_avx512bw_vec_dupv64qi_1 (rtx, rtx);
extern rtx gen_avx512f_vec_dupv16si (rtx, rtx);
extern rtx gen_avx512f_vec_dupv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv8si (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4si (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dupv8di (rtx, rtx);
extern rtx gen_avx512f_vec_dupv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4di (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv2di (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dupv16sf (rtx, rtx);
extern rtx gen_avx512f_vec_dupv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv8sf (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4sf (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dupv8df (rtx, rtx);
extern rtx gen_avx512f_vec_dupv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4df (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv2df (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vec_dupv64qi (rtx, rtx);
extern rtx gen_avx512bw_vec_dupv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv16qi (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv32qi (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vec_dupv32hi (rtx, rtx);
extern rtx gen_avx512bw_vec_dupv32hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv16hi (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv16hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dupv8hi (rtx, rtx);
extern rtx gen_avx512vl_vec_dupv8hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_broadcastv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_broadcastv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_broadcastv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_broadcastv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vec_dup_gprv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vec_dup_gprv32hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv16hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv8hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dup_gprv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dup_gprv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dup_gprv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vec_dup_gprv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vec_dup_gprv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vec_dupv4sf (rtx, rtx);
extern rtx gen_avx2_vbroadcasti128_v32qi (rtx, rtx);
extern rtx gen_avx2_vbroadcasti128_v16hi (rtx, rtx);
extern rtx gen_avx2_vbroadcasti128_v8si (rtx, rtx);
extern rtx gen_avx2_vbroadcasti128_v4di (rtx, rtx);
extern rtx gen_vec_dupv8si (rtx, rtx);
extern rtx gen_vec_dupv8sf (rtx, rtx);
extern rtx gen_vec_dupv4di (rtx, rtx);
extern rtx gen_vec_dupv4df (rtx, rtx);
extern rtx gen_avx_vbroadcastf128_v32qi (rtx, rtx);
extern rtx gen_avx_vbroadcastf128_v16hi (rtx, rtx);
extern rtx gen_avx_vbroadcastf128_v8si (rtx, rtx);
extern rtx gen_avx_vbroadcastf128_v4di (rtx, rtx);
extern rtx gen_avx_vbroadcastf128_v8sf (rtx, rtx);
extern rtx gen_avx_vbroadcastf128_v4df (rtx, rtx);
extern rtx gen_avx512dq_broadcastv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_broadcastv8si_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_broadcastv8sf_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv16sf_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv16si_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv8di_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv8df_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv4di_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_broadcastv4df_mask_1 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512cd_maskb_vec_dupv8di (rtx, rtx);
extern rtx gen_avx512cd_maskb_vec_dupv4di (rtx, rtx);
extern rtx gen_avx512cd_maskb_vec_dupv2di (rtx, rtx);
extern rtx gen_avx512cd_maskw_vec_dupv16si (rtx, rtx);
extern rtx gen_avx512cd_maskw_vec_dupv8si (rtx, rtx);
extern rtx gen_avx512cd_maskw_vec_dupv4si (rtx, rtx);
extern rtx gen_avx512f_vpermilvarv16sf3 (rtx, rtx, rtx);
extern rtx gen_avx512f_vpermilvarv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv8sf3 (rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv4sf3 (rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermilvarv8df3 (rtx, rtx, rtx);
extern rtx gen_avx512f_vpermilvarv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv4df3 (rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv2df3 (rtx, rtx, rtx);
extern rtx gen_avx_vpermilvarv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16si3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16sf3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8di3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8df3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8si3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8sf3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4di3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4df3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4si3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4sf3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2di3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2di3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2df3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv32hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv32hi3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16hi3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8hi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8hi3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv64qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv64qi3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv32qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv32qi3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16qi3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16qi3_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v4di (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v4df (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v4di (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v4df (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8si (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8sf (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8si (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8sf (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_set_lo_v32qi (rtx, rtx, rtx);
extern rtx gen_vec_set_hi_v32qi (rtx, rtx, rtx);
extern rtx gen_avx_maskloadps (rtx, rtx, rtx);
extern rtx gen_avx_maskloadpd (rtx, rtx, rtx);
extern rtx gen_avx_maskloadps256 (rtx, rtx, rtx);
extern rtx gen_avx_maskloadpd256 (rtx, rtx, rtx);
extern rtx gen_avx2_maskloadd (rtx, rtx, rtx);
extern rtx gen_avx2_maskloadq (rtx, rtx, rtx);
extern rtx gen_avx2_maskloadd256 (rtx, rtx, rtx);
extern rtx gen_avx2_maskloadq256 (rtx, rtx, rtx);
extern rtx gen_avx_maskstoreps (rtx, rtx, rtx);
extern rtx gen_avx_maskstorepd (rtx, rtx, rtx);
extern rtx gen_avx_maskstoreps256 (rtx, rtx, rtx);
extern rtx gen_avx_maskstorepd256 (rtx, rtx, rtx);
extern rtx gen_avx2_maskstored (rtx, rtx, rtx);
extern rtx gen_avx2_maskstoreq (rtx, rtx, rtx);
extern rtx gen_avx2_maskstored256 (rtx, rtx, rtx);
extern rtx gen_avx2_maskstoreq256 (rtx, rtx, rtx);
extern rtx gen_avx_si256_si (rtx, rtx);
extern rtx gen_avx_ps256_ps (rtx, rtx);
extern rtx gen_avx_pd256_pd (rtx, rtx);
extern rtx gen_avx2_ashrvv4si (rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv8si (rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ashrvv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_ashrvv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv2di (rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv4di (rtx, rtx, rtx);
extern rtx gen_avx2_ashrvv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ashrvv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_ashrvv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ashrvv8hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_ashrvv8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ashrvv16hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_ashrvv16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ashrvv32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_ashrvv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ashlvv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_ashlvv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_lshrvv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_lshrvv16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv8si (rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv8si (rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv4si (rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv4si (rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_ashlvv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_ashlvv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_lshrvv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_lshrvv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv4di (rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv4di (rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv2di (rtx, rtx, rtx);
extern rtx gen_avx2_ashlvv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv2di (rtx, rtx, rtx);
extern rtx gen_avx2_lshrvv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ashlvv8hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_ashlvv8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_lshrvv8hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_lshrvv8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_ashlvv16hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_ashlvv16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_lshrvv16hi (rtx, rtx, rtx);
extern rtx gen_avx512vl_lshrvv16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ashlvv32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_ashlvv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_lshrvv32hi (rtx, rtx, rtx);
extern rtx gen_avx512bw_lshrvv32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv32qi (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv16hi (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv8si (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv4di (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv8sf (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv4df (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv64qi (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv32hi (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv16si (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv8di (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv16sf (rtx, rtx, rtx);
extern rtx gen_avx_vec_concatv8df (rtx, rtx, rtx);
extern rtx gen_vcvtph2ps (rtx, rtx);
extern rtx gen_vcvtph2ps_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vcvtph2ps256 (rtx, rtx);
extern rtx gen_vcvtph2ps256_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtph2ps512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtph2ps512_mask_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcvtps2ph256 (rtx, rtx, rtx);
extern rtx gen_vcvtps2ph256_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vcvtps2ph512_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_compressv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_compressv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_compressv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_compressv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_compressv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_compressv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_compressv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_compressv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_compressv32hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_compressv16hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_compressv8hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_compressstorev16si_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_compressstorev16sf_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_compressstorev8di_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_compressstorev8df_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev8si_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev8sf_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev4di_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev4df_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev4si_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev4sf_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev2di_mask (rtx, rtx, rtx);
extern rtx gen_avx512vl_compressstorev2df_mask (rtx, rtx, rtx);
extern rtx gen_compressstorev64qi_mask (rtx, rtx, rtx);
extern rtx gen_compressstorev16qi_mask (rtx, rtx, rtx);
extern rtx gen_compressstorev32qi_mask (rtx, rtx, rtx);
extern rtx gen_compressstorev32hi_mask (rtx, rtx, rtx);
extern rtx gen_compressstorev16hi_mask (rtx, rtx, rtx);
extern rtx gen_compressstorev8hi_mask (rtx, rtx, rtx);
extern rtx gen_avx512f_expandv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_expandv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_expandv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_expandv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_expandv32hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_expandv16hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_expandv8hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv16sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv16sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv16sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv8sf (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv8sf_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv8sf_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv8sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv8sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv4sf (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv4sf_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv4sf_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv4sf_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv8df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv8df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv8df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangepv4df (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv4df_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv4df_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv4df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv4df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv2df (rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv2df_round (rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv2df_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangepv2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_avx512dq_rangepv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_avx512dq_rangepv2df_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)), rtx g __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_avx512dq_rangesv4sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv2df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_rangesv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv16sf (rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv8sf (rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv4sf (rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv8df (rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv8df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv4df (rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv4df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv2df (rtx, rtx, rtx);
extern rtx gen_avx512dq_fpclassv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vmfpclassv4sf (rtx, rtx, rtx);
extern rtx gen_avx512dq_vmfpclassv4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vmfpclassv2df (rtx, rtx, rtx);
extern rtx gen_avx512dq_vmfpclassv2df_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv16sf (rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv16sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv16sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv8sf (rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv8sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv8sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4sf (rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4sf_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv8df (rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv8df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_getmantv8df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4df (rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv4df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv2df (rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv2df_round (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_getmantv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv4sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv4sf_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv4sf_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv2df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv2df_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vgetmantv2df_mask_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_dbpsadbwv8hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_dbpsadbwv16hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_dbpsadbwv32hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_clzv16si2 (rtx, rtx);
extern rtx gen_clzv16si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_clzv8si2 (rtx, rtx);
extern rtx gen_clzv8si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_clzv4si2 (rtx, rtx);
extern rtx gen_clzv4si2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_clzv8di2 (rtx, rtx);
extern rtx gen_clzv8di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_clzv4di2 (rtx, rtx);
extern rtx gen_clzv4di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_clzv2di2 (rtx, rtx);
extern rtx gen_clzv2di2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_conflictv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_conflictv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_conflictv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_conflictv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_conflictv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_conflictv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sha1msg1 (rtx, rtx, rtx);
extern rtx gen_sha1msg2 (rtx, rtx, rtx);
extern rtx gen_sha1nexte (rtx, rtx, rtx);
extern rtx gen_sha1rnds4 (rtx, rtx, rtx, rtx);
extern rtx gen_sha256msg1 (rtx, rtx, rtx);
extern rtx gen_sha256msg2 (rtx, rtx, rtx);
extern rtx gen_sha256rnds2 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_si512_si (rtx, rtx);
extern rtx gen_avx512f_ps512_ps (rtx, rtx);
extern rtx gen_avx512f_pd512_pd (rtx, rtx);
extern rtx gen_avx512f_si512_256si (rtx, rtx);
extern rtx gen_avx512f_ps512_256ps (rtx, rtx);
extern rtx gen_avx512f_pd512_256pd (rtx, rtx);
extern rtx gen_vpamdd52luqv8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv8di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv8di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv4di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv4di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv2di (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv2di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv2di (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv2di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpmultishiftqbv64qi (rtx, rtx, rtx);
extern rtx gen_vpmultishiftqbv64qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpmultishiftqbv16qi (rtx, rtx, rtx);
extern rtx gen_vpmultishiftqbv16qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpmultishiftqbv32qi (rtx, rtx, rtx);
extern rtx gen_vpmultishiftqbv32qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fmaddps (rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fmaddps_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fmaddps_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fmaddss (rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fmaddss_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fmaddss_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fnmaddps (rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fnmaddps_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fnmaddps_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fnmaddss (rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fnmaddss_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124fmaddps_4fnmaddss_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124vnniw_vp4dpwssd (rtx, rtx, rtx, rtx);
extern rtx gen_avx5124vnniw_vp4dpwssd_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124vnniw_vp4dpwssd_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124vnniw_vp4dpwssds (rtx, rtx, rtx, rtx);
extern rtx gen_avx5124vnniw_vp4dpwssds_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx5124vnniw_vp4dpwssds_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv16si (rtx, rtx);
extern rtx gen_vpopcountv16si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv8si (rtx, rtx);
extern rtx gen_vpopcountv8si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv4si (rtx, rtx);
extern rtx gen_vpopcountv4si_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv8di (rtx, rtx);
extern rtx gen_vpopcountv8di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv4di (rtx, rtx);
extern rtx gen_vpopcountv4di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv2di (rtx, rtx);
extern rtx gen_vpopcountv2di_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv64qi (rtx, rtx);
extern rtx gen_vpopcountv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv16qi (rtx, rtx);
extern rtx gen_vpopcountv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv32qi (rtx, rtx);
extern rtx gen_vpopcountv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv32hi (rtx, rtx);
extern rtx gen_vpopcountv32hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv16hi (rtx, rtx);
extern rtx gen_vpopcountv16hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vpopcountv8hi (rtx, rtx);
extern rtx gen_vpopcountv8hi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineinvqb_v64qi (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineinvqb_v64qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineinvqb_v32qi (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineinvqb_v32qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineinvqb_v16qi (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineinvqb_v16qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineqb_v64qi (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineqb_v64qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineqb_v32qi (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineqb_v32qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineqb_v16qi (rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8affineqb_v16qi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8mulb_v64qi (rtx, rtx, rtx);
extern rtx gen_vgf2p8mulb_v64qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8mulb_v32qi (rtx, rtx, rtx);
extern rtx gen_vgf2p8mulb_v32qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vgf2p8mulb_v16qi (rtx, rtx, rtx);
extern rtx gen_vgf2p8mulb_v16qi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v32hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v32hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v16si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v8di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v16hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v8si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v4di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v8hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v4si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v2di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrd_v2di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v32hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v32hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v16si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v8di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v16hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v8si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v4di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v8hi_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v4si_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v2di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshld_v2di_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v32hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v2di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v32hi_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16hi_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8hi_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v2di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v32hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v2di (rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v2di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v32hi_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16hi_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8hi_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v2di_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v16si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v8si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v4si (rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v16si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v8si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v4si_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vaesdec_v32qi (rtx, rtx, rtx);
extern rtx gen_vaesdec_v16qi (rtx, rtx, rtx);
extern rtx gen_vaesdec_v64qi (rtx, rtx, rtx);
extern rtx gen_vaesdeclast_v32qi (rtx, rtx, rtx);
extern rtx gen_vaesdeclast_v16qi (rtx, rtx, rtx);
extern rtx gen_vaesdeclast_v64qi (rtx, rtx, rtx);
extern rtx gen_vaesenc_v32qi (rtx, rtx, rtx);
extern rtx gen_vaesenc_v16qi (rtx, rtx, rtx);
extern rtx gen_vaesenc_v64qi (rtx, rtx, rtx);
extern rtx gen_vaesenclast_v32qi (rtx, rtx, rtx);
extern rtx gen_vaesenclast_v16qi (rtx, rtx, rtx);
extern rtx gen_vaesenclast_v64qi (rtx, rtx, rtx);
extern rtx gen_vpclmulqdq_v8di (rtx, rtx, rtx, rtx);
extern rtx gen_vpclmulqdq_v4di (rtx, rtx, rtx, rtx);
extern rtx gen_vpclmulqdq_v2di (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpshufbitqmbv64qi (rtx, rtx, rtx);
extern rtx gen_avx512vl_vpshufbitqmbv64qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpshufbitqmbv32qi (rtx, rtx, rtx);
extern rtx gen_avx512vl_vpshufbitqmbv32qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpshufbitqmbv16qi (rtx, rtx, rtx);
extern rtx gen_avx512vl_vpshufbitqmbv16qi_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vp2intersect_2intersectv8di (rtx, rtx, rtx);
extern rtx gen_avx512vp2intersect_2intersectv4di (rtx, rtx, rtx);
extern rtx gen_avx512vp2intersect_2intersectv2di (rtx, rtx, rtx);
extern rtx gen_avx512vp2intersect_2intersectv8si (rtx, rtx, rtx);
extern rtx gen_avx512vp2intersect_2intersectv4si (rtx, rtx, rtx);
extern rtx gen_avx512vp2intersect_2intersectv16si (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v32hi (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v32hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v16hi (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v16hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v8hi (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v8hi_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v16sf (rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v16sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v8sf (rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v8sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v4sf (rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v4sf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v16sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v16sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v8sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v4sf_maskz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mfence_sse2 (rtx);
extern rtx gen_mfence_nosse (rtx);
extern rtx gen_atomic_loaddi_fpu (rtx, rtx, rtx);
extern rtx gen_atomic_storeqi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_storehi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_storesi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_storedi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_storedi_fpu (rtx, rtx, rtx);
extern rtx gen_loaddi_via_fpu (rtx, rtx);
extern rtx gen_storedi_via_fpu (rtx, rtx);
extern rtx gen_loaddi_via_sse (rtx, rtx);
extern rtx gen_storedi_via_sse (rtx, rtx);
extern rtx gen_atomic_compare_and_swapdi_doubleword (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapti_doubleword (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapqi_1 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swaphi_1 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapsi_1 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapdi_1 (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_fetch_addqi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_fetch_addhi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_fetch_addsi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_fetch_adddi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_exchangeqi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_exchangehi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_exchangesi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_exchangedi (rtx, rtx, rtx, rtx);
extern rtx gen_atomic_addqi (rtx, rtx, rtx);
extern rtx gen_atomic_addhi (rtx, rtx, rtx);
extern rtx gen_atomic_addsi (rtx, rtx, rtx);
extern rtx gen_atomic_adddi (rtx, rtx, rtx);
extern rtx gen_atomic_subqi (rtx, rtx, rtx);
extern rtx gen_atomic_subhi (rtx, rtx, rtx);
extern rtx gen_atomic_subsi (rtx, rtx, rtx);
extern rtx gen_atomic_subdi (rtx, rtx, rtx);
extern rtx gen_atomic_andqi (rtx, rtx, rtx);
extern rtx gen_atomic_orqi (rtx, rtx, rtx);
extern rtx gen_atomic_xorqi (rtx, rtx, rtx);
extern rtx gen_atomic_andhi (rtx, rtx, rtx);
extern rtx gen_atomic_orhi (rtx, rtx, rtx);
extern rtx gen_atomic_xorhi (rtx, rtx, rtx);
extern rtx gen_atomic_andsi (rtx, rtx, rtx);
extern rtx gen_atomic_orsi (rtx, rtx, rtx);
extern rtx gen_atomic_xorsi (rtx, rtx, rtx);
extern rtx gen_atomic_anddi (rtx, rtx, rtx);
extern rtx gen_atomic_ordi (rtx, rtx, rtx);
extern rtx gen_atomic_xordi (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_sethi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_setsi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_setdi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_complementhi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_complementsi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_complementdi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_resethi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_resetsi_1 (rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_resetdi_1 (rtx, rtx, rtx);
extern rtx gen_cbranchqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchti4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstoreqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstorehi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstoresi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstoredi4 (rtx, rtx, rtx, rtx);
extern rtx gen_cmpsi_1 (rtx, rtx);
extern rtx gen_cmpdi_1 (rtx, rtx);
extern rtx gen_cmpqi_ext_3 (rtx, rtx);
extern rtx gen_cbranchxf4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstorexf4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchsf4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchdf4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstoresf4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstoredf4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchcc4 (rtx, rtx, rtx, rtx);
extern rtx gen_cstorecc4 (rtx, rtx, rtx, rtx);
extern rtx gen_reload_noff_store (rtx, rtx, rtx);
extern rtx gen_reload_noff_load (rtx, rtx, rtx);
extern rtx gen_movxi (rtx, rtx);
extern rtx gen_movoi (rtx, rtx);
extern rtx gen_movti (rtx, rtx);
extern rtx gen_movcdi (rtx, rtx);
extern rtx gen_movqi (rtx, rtx);
extern rtx gen_movhi (rtx, rtx);
extern rtx gen_movsi (rtx, rtx);
extern rtx gen_movdi (rtx, rtx);
extern rtx gen_movstrictqi (rtx, rtx);
extern rtx gen_movstricthi (rtx, rtx);
extern rtx gen_extvhi (rtx, rtx, rtx, rtx);
extern rtx gen_extvsi (rtx, rtx, rtx, rtx);
extern rtx gen_extzvhi (rtx, rtx, rtx, rtx);
extern rtx gen_extzvsi (rtx, rtx, rtx, rtx);
extern rtx gen_extzvdi (rtx, rtx, rtx, rtx);
extern rtx gen_insvhi (rtx, rtx, rtx, rtx);
extern rtx gen_insvsi (rtx, rtx, rtx, rtx);
extern rtx gen_insvdi (rtx, rtx, rtx, rtx);
extern rtx gen_movtf (rtx, rtx);
extern rtx gen_movsf (rtx, rtx);
extern rtx gen_movdf (rtx, rtx);
extern rtx gen_movxf (rtx, rtx);
extern rtx gen_zero_extendsidi2 (rtx, rtx);
extern rtx gen_zero_extendqisi2 (rtx, rtx);
extern rtx gen_zero_extendhisi2 (rtx, rtx);
extern rtx gen_zero_extendqihi2 (rtx, rtx);
extern rtx gen_extendsidi2 (rtx, rtx);
extern rtx gen_extendsfdf2 (rtx, rtx);
extern rtx gen_extendsfxf2 (rtx, rtx);
extern rtx gen_extenddfxf2 (rtx, rtx);
extern rtx gen_fix_truncxfdi2 (rtx, rtx);
extern rtx gen_fix_truncsfdi2 (rtx, rtx);
extern rtx gen_fix_truncdfdi2 (rtx, rtx);
extern rtx gen_fix_truncxfsi2 (rtx, rtx);
extern rtx gen_fix_truncsfsi2 (rtx, rtx);
extern rtx gen_fix_truncdfsi2 (rtx, rtx);
extern rtx gen_fix_truncsfhi2 (rtx, rtx);
extern rtx gen_fix_truncdfhi2 (rtx, rtx);
extern rtx gen_fix_truncxfhi2 (rtx, rtx);
extern rtx gen_fixuns_truncsfsi2 (rtx, rtx);
extern rtx gen_fixuns_truncdfsi2 (rtx, rtx);
extern rtx gen_fixuns_truncsfhi2 (rtx, rtx);
extern rtx gen_fixuns_truncdfhi2 (rtx, rtx);
extern rtx gen_floatsisf2 (rtx, rtx);
extern rtx gen_floatdisf2 (rtx, rtx);
extern rtx gen_floatsidf2 (rtx, rtx);
extern rtx gen_floatdidf2 (rtx, rtx);
extern rtx gen_floatunsqisf2 (rtx, rtx);
extern rtx gen_floatunshisf2 (rtx, rtx);
extern rtx gen_floatunsqidf2 (rtx, rtx);
extern rtx gen_floatunshidf2 (rtx, rtx);
extern rtx gen_floatunssisf2 (rtx, rtx);
extern rtx gen_floatunssidf2 (rtx, rtx);
extern rtx gen_floatunssixf2 (rtx, rtx);
extern rtx gen_floatunsdisf2 (rtx, rtx);
extern rtx gen_floatunsdidf2 (rtx, rtx);
extern rtx gen_addqi3 (rtx, rtx, rtx);
extern rtx gen_addhi3 (rtx, rtx, rtx);
extern rtx gen_addsi3 (rtx, rtx, rtx);
extern rtx gen_adddi3 (rtx, rtx, rtx);
extern rtx gen_addti3 (rtx, rtx, rtx);
extern rtx gen_addqi_ext_1 (rtx, rtx, rtx);
extern rtx gen_addvqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_addvhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_addvsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_addvdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_addvti4 (rtx, rtx, rtx, rtx);
extern rtx gen_uaddvqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_uaddvhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_uaddvsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_uaddvdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_uaddvti4 (rtx, rtx, rtx, rtx);
extern rtx gen_subqi3 (rtx, rtx, rtx);
extern rtx gen_subhi3 (rtx, rtx, rtx);
extern rtx gen_subsi3 (rtx, rtx, rtx);
extern rtx gen_subdi3 (rtx, rtx, rtx);
extern rtx gen_subti3 (rtx, rtx, rtx);
extern rtx gen_subvqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_subvhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_subvsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_subvdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_subvti4 (rtx, rtx, rtx, rtx);
extern rtx gen_usubvqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_usubvhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_usubvsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_usubvdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_addcarrysi_0 (rtx, rtx, rtx);
extern rtx gen_addcarrydi_0 (rtx, rtx, rtx);
extern rtx gen_subborrowsi_0 (rtx, rtx, rtx);
extern rtx gen_subborrowdi_0 (rtx, rtx, rtx);
extern rtx gen_addqi3_cconly_overflow (rtx, rtx);
extern rtx gen_addxf3 (rtx, rtx, rtx);
extern rtx gen_subxf3 (rtx, rtx, rtx);
extern rtx gen_addsf3 (rtx, rtx, rtx);
extern rtx gen_subsf3 (rtx, rtx, rtx);
extern rtx gen_adddf3 (rtx, rtx, rtx);
extern rtx gen_subdf3 (rtx, rtx, rtx);
extern rtx gen_mulhi3 (rtx, rtx, rtx);
extern rtx gen_mulsi3 (rtx, rtx, rtx);
extern rtx gen_muldi3 (rtx, rtx, rtx);
extern rtx gen_mulqi3 (rtx, rtx, rtx);
extern rtx gen_mulvhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_mulvsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_mulvdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_umulvhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_umulvsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_umulvdi4 (rtx, rtx, rtx, rtx);
extern rtx gen_mulvqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_umulvqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_mulsidi3 (rtx, rtx, rtx);
extern rtx gen_umulsidi3 (rtx, rtx, rtx);
extern rtx gen_mulditi3 (rtx, rtx, rtx);
extern rtx gen_umulditi3 (rtx, rtx, rtx);
extern rtx gen_mulqihi3 (rtx, rtx, rtx);
extern rtx gen_umulqihi3 (rtx, rtx, rtx);
extern rtx gen_smulsi3_highpart (rtx, rtx, rtx);
extern rtx gen_umulsi3_highpart (rtx, rtx, rtx);
extern rtx gen_smuldi3_highpart (rtx, rtx, rtx);
extern rtx gen_umuldi3_highpart (rtx, rtx, rtx);
extern rtx gen_mulxf3 (rtx, rtx, rtx);
extern rtx gen_mulsf3 (rtx, rtx, rtx);
extern rtx gen_muldf3 (rtx, rtx, rtx);
extern rtx gen_divxf3 (rtx, rtx, rtx);
extern rtx gen_divsf3 (rtx, rtx, rtx);
extern rtx gen_divdf3 (rtx, rtx, rtx);
extern rtx gen_divmodhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmodhi4 (rtx, rtx, rtx, rtx);
extern rtx gen_divmodsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmodsi4 (rtx, rtx, rtx, rtx);
extern rtx gen_divmoddi4 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmoddi4 (rtx, rtx, rtx, rtx);
extern rtx gen_divmodqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_udivmodqi4 (rtx, rtx, rtx, rtx);
extern rtx gen_testsi_ccno_1 (rtx, rtx);
extern rtx gen_testdi_ccno_1 (rtx, rtx);
extern rtx gen_testqi_ccz_1 (rtx, rtx);
extern rtx gen_testqi_ext_1_ccno (rtx, rtx);
extern rtx gen_andqi3 (rtx, rtx, rtx);
extern rtx gen_andhi3 (rtx, rtx, rtx);
extern rtx gen_andsi3 (rtx, rtx, rtx);
extern rtx gen_anddi3 (rtx, rtx, rtx);
extern rtx gen_andqi_ext_1 (rtx, rtx, rtx);
extern rtx gen_iorqi3 (rtx, rtx, rtx);
extern rtx gen_xorqi3 (rtx, rtx, rtx);
extern rtx gen_iorhi3 (rtx, rtx, rtx);
extern rtx gen_xorhi3 (rtx, rtx, rtx);
extern rtx gen_iorsi3 (rtx, rtx, rtx);
extern rtx gen_xorsi3 (rtx, rtx, rtx);
extern rtx gen_iordi3 (rtx, rtx, rtx);
extern rtx gen_xordi3 (rtx, rtx, rtx);
extern rtx gen_xorqi_ext_1_cc (rtx, rtx, rtx);
extern rtx gen_negqi2 (rtx, rtx);
extern rtx gen_neghi2 (rtx, rtx);
extern rtx gen_negsi2 (rtx, rtx);
extern rtx gen_negdi2 (rtx, rtx);
extern rtx gen_negti2 (rtx, rtx);
extern rtx gen_negvqi3 (rtx, rtx, rtx);
extern rtx gen_negvhi3 (rtx, rtx, rtx);
extern rtx gen_negvsi3 (rtx, rtx, rtx);
extern rtx gen_negvdi3 (rtx, rtx, rtx);
extern rtx gen_abssi2 (rtx, rtx);
extern rtx gen_absdi2 (rtx, rtx);
extern rtx gen_abstf2 (rtx, rtx);
extern rtx gen_negtf2 (rtx, rtx);
extern rtx gen_abssf2 (rtx, rtx);
extern rtx gen_negsf2 (rtx, rtx);
extern rtx gen_absdf2 (rtx, rtx);
extern rtx gen_negdf2 (rtx, rtx);
extern rtx gen_absxf2 (rtx, rtx);
extern rtx gen_negxf2 (rtx, rtx);
extern rtx gen_copysignsf3 (rtx, rtx, rtx);
extern rtx gen_copysigndf3 (rtx, rtx, rtx);
extern rtx gen_copysigntf3 (rtx, rtx, rtx);
extern rtx gen_xorsignsf3 (rtx, rtx, rtx);
extern rtx gen_xorsigndf3 (rtx, rtx, rtx);
extern rtx gen_one_cmplqi2 (rtx, rtx);
extern rtx gen_one_cmplhi2 (rtx, rtx);
extern rtx gen_one_cmplsi2 (rtx, rtx);
extern rtx gen_one_cmpldi2 (rtx, rtx);
extern rtx gen_ashlqi3 (rtx, rtx, rtx);
extern rtx gen_ashlhi3 (rtx, rtx, rtx);
extern rtx gen_ashlsi3 (rtx, rtx, rtx);
extern rtx gen_ashldi3 (rtx, rtx, rtx);
extern rtx gen_ashlti3 (rtx, rtx, rtx);
extern rtx gen_x86_shiftsi_adj_1 (rtx, rtx, rtx, rtx);
extern rtx gen_x86_shiftdi_adj_1 (rtx, rtx, rtx, rtx);
extern rtx gen_x86_shiftsi_adj_2 (rtx, rtx, rtx);
extern rtx gen_x86_shiftdi_adj_2 (rtx, rtx, rtx);
extern rtx gen_lshrqi3 (rtx, rtx, rtx);
extern rtx gen_ashrqi3 (rtx, rtx, rtx);
extern rtx gen_lshrhi3 (rtx, rtx, rtx);
extern rtx gen_ashrhi3 (rtx, rtx, rtx);
extern rtx gen_lshrsi3 (rtx, rtx, rtx);
extern rtx gen_ashrsi3 (rtx, rtx, rtx);
extern rtx gen_lshrdi3 (rtx, rtx, rtx);
extern rtx gen_ashrdi3 (rtx, rtx, rtx);
extern rtx gen_lshrti3 (rtx, rtx, rtx);
extern rtx gen_ashrti3 (rtx, rtx, rtx);
extern rtx gen_x86_shiftsi_adj_3 (rtx, rtx, rtx);
extern rtx gen_x86_shiftdi_adj_3 (rtx, rtx, rtx);
extern rtx gen_rotlti3 (rtx, rtx, rtx);
extern rtx gen_rotrti3 (rtx, rtx, rtx);
extern rtx gen_rotldi3 (rtx, rtx, rtx);
extern rtx gen_rotrdi3 (rtx, rtx, rtx);
extern rtx gen_rotlqi3 (rtx, rtx, rtx);
extern rtx gen_rotrqi3 (rtx, rtx, rtx);
extern rtx gen_rotlhi3 (rtx, rtx, rtx);
extern rtx gen_rotrhi3 (rtx, rtx, rtx);
extern rtx gen_rotlsi3 (rtx, rtx, rtx);
extern rtx gen_rotrsi3 (rtx, rtx, rtx);
extern rtx gen_indirect_jump (rtx);
extern rtx gen_tablejump (rtx, rtx);
extern rtx gen_call (rtx, rtx, rtx);
extern rtx gen_sibcall (rtx, rtx, rtx);
extern rtx gen_call_pop (rtx, rtx, rtx, rtx);
extern rtx gen_call_value (rtx, rtx, rtx, rtx);
extern rtx gen_sibcall_value (rtx, rtx, rtx, rtx);
extern rtx gen_call_value_pop (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_untyped_call (rtx, rtx, rtx);
extern rtx gen_memory_blockage (void);
extern rtx gen_return (void);
extern rtx gen_simple_return (void);
extern rtx gen_simple_return_indirect_internal (rtx);
extern rtx gen_prologue (void);
extern rtx gen_set_got (rtx);
extern rtx gen_set_got_labelled (rtx, rtx);
extern rtx gen_epilogue (void);
extern rtx gen_sibcall_epilogue (void);
extern rtx gen_eh_return (rtx);
extern rtx gen_leave_si (void);
extern rtx gen_leave_di (void);
extern rtx gen_split_stack_prologue (void);
extern rtx gen_split_stack_space_check (rtx, rtx);
extern rtx gen_ffssi2 (rtx, rtx);
extern rtx gen_ffsdi2 (rtx, rtx);
extern rtx gen_clzsi2 (rtx, rtx);
extern rtx gen_clzdi2 (rtx, rtx);
extern rtx gen_bmi2_bzhi_si3 (rtx, rtx, rtx);
extern rtx gen_bmi2_bzhi_di3 (rtx, rtx, rtx);
extern rtx gen_tbm_bextri_si (rtx, rtx, rtx, rtx);
extern rtx gen_tbm_bextri_di (rtx, rtx, rtx, rtx);
extern rtx gen_bswapdi2 (rtx, rtx);
extern rtx gen_bswapsi2 (rtx, rtx);
extern rtx gen_bswaphi2 (rtx, rtx);
extern rtx gen_paritydi2 (rtx, rtx);
extern rtx gen_paritysi2 (rtx, rtx);
extern rtx gen_parityhi2 (rtx, rtx);
extern rtx gen_parityqi2 (rtx, rtx);
extern rtx gen_tls_global_dynamic_32 (rtx, rtx, rtx, rtx);
extern rtx gen_tls_global_dynamic_64_si (rtx, rtx, rtx);
extern rtx gen_tls_global_dynamic_64_di (rtx, rtx, rtx);
extern rtx gen_tls_local_dynamic_base_32 (rtx, rtx, rtx);
extern rtx gen_tls_local_dynamic_base_64_si (rtx, rtx);
extern rtx gen_tls_local_dynamic_base_64_di (rtx, rtx);
extern rtx gen_tls_dynamic_gnu2_32 (rtx, rtx, rtx);
extern rtx gen_tls_dynamic_gnu2_64_si (rtx, rtx);
extern rtx gen_tls_dynamic_gnu2_64_di (rtx, rtx);
extern rtx gen_rsqrtsf2 (rtx, rtx);
extern rtx gen_sqrtsf2 (rtx, rtx);
extern rtx gen_sqrtdf2 (rtx, rtx);
extern rtx gen_hypotsf3 (rtx, rtx, rtx);
extern rtx gen_hypotdf3 (rtx, rtx, rtx);
extern rtx gen_fmodxf3 (rtx, rtx, rtx);
extern rtx gen_fmodsf3 (rtx, rtx, rtx);
extern rtx gen_fmoddf3 (rtx, rtx, rtx);
extern rtx gen_remainderxf3 (rtx, rtx, rtx);
extern rtx gen_remaindersf3 (rtx, rtx, rtx);
extern rtx gen_remainderdf3 (rtx, rtx, rtx);
extern rtx gen_sinsf2 (rtx, rtx);
extern rtx gen_cossf2 (rtx, rtx);
extern rtx gen_sindf2 (rtx, rtx);
extern rtx gen_cosdf2 (rtx, rtx);
extern rtx gen_sincossf3 (rtx, rtx, rtx);
extern rtx gen_sincosdf3 (rtx, rtx, rtx);
extern rtx gen_tanxf2 (rtx, rtx);
extern rtx gen_tansf2 (rtx, rtx);
extern rtx gen_tandf2 (rtx, rtx);
extern rtx gen_atan2sf3 (rtx, rtx, rtx);
extern rtx gen_atan2df3 (rtx, rtx, rtx);
extern rtx gen_atanxf2 (rtx, rtx);
extern rtx gen_atansf2 (rtx, rtx);
extern rtx gen_atandf2 (rtx, rtx);
extern rtx gen_asinxf2 (rtx, rtx);
extern rtx gen_asinsf2 (rtx, rtx);
extern rtx gen_asindf2 (rtx, rtx);
extern rtx gen_acosxf2 (rtx, rtx);
extern rtx gen_acossf2 (rtx, rtx);
extern rtx gen_acosdf2 (rtx, rtx);
extern rtx gen_sinhxf2 (rtx, rtx);
extern rtx gen_sinhsf2 (rtx, rtx);
extern rtx gen_sinhdf2 (rtx, rtx);
extern rtx gen_coshxf2 (rtx, rtx);
extern rtx gen_coshsf2 (rtx, rtx);
extern rtx gen_coshdf2 (rtx, rtx);
extern rtx gen_tanhxf2 (rtx, rtx);
extern rtx gen_tanhsf2 (rtx, rtx);
extern rtx gen_tanhdf2 (rtx, rtx);
extern rtx gen_asinhxf2 (rtx, rtx);
extern rtx gen_asinhsf2 (rtx, rtx);
extern rtx gen_asinhdf2 (rtx, rtx);
extern rtx gen_acoshxf2 (rtx, rtx);
extern rtx gen_acoshsf2 (rtx, rtx);
extern rtx gen_acoshdf2 (rtx, rtx);
extern rtx gen_atanhxf2 (rtx, rtx);
extern rtx gen_atanhsf2 (rtx, rtx);
extern rtx gen_atanhdf2 (rtx, rtx);
extern rtx gen_logxf2 (rtx, rtx);
extern rtx gen_logsf2 (rtx, rtx);
extern rtx gen_logdf2 (rtx, rtx);
extern rtx gen_log10xf2 (rtx, rtx);
extern rtx gen_log10sf2 (rtx, rtx);
extern rtx gen_log10df2 (rtx, rtx);
extern rtx gen_log2xf2 (rtx, rtx);
extern rtx gen_log2sf2 (rtx, rtx);
extern rtx gen_log2df2 (rtx, rtx);
extern rtx gen_log1pxf2 (rtx, rtx);
extern rtx gen_log1psf2 (rtx, rtx);
extern rtx gen_log1pdf2 (rtx, rtx);
extern rtx gen_logbxf2 (rtx, rtx);
extern rtx gen_logbsf2 (rtx, rtx);
extern rtx gen_logbdf2 (rtx, rtx);
extern rtx gen_ilogbxf2 (rtx, rtx);
extern rtx gen_ilogbsf2 (rtx, rtx);
extern rtx gen_ilogbdf2 (rtx, rtx);
extern rtx gen_expNcorexf3 (rtx, rtx, rtx);
extern rtx gen_expxf2 (rtx, rtx);
extern rtx gen_expsf2 (rtx, rtx);
extern rtx gen_expdf2 (rtx, rtx);
extern rtx gen_exp10xf2 (rtx, rtx);
extern rtx gen_exp10sf2 (rtx, rtx);
extern rtx gen_exp10df2 (rtx, rtx);
extern rtx gen_exp2xf2 (rtx, rtx);
extern rtx gen_exp2sf2 (rtx, rtx);
extern rtx gen_exp2df2 (rtx, rtx);
extern rtx gen_expm1xf2 (rtx, rtx);
extern rtx gen_expm1sf2 (rtx, rtx);
extern rtx gen_expm1df2 (rtx, rtx);
extern rtx gen_ldexpxf3 (rtx, rtx, rtx);
extern rtx gen_ldexpsf3 (rtx, rtx, rtx);
extern rtx gen_ldexpdf3 (rtx, rtx, rtx);
extern rtx gen_scalbxf3 (rtx, rtx, rtx);
extern rtx gen_scalbsf3 (rtx, rtx, rtx);
extern rtx gen_scalbdf3 (rtx, rtx, rtx);
extern rtx gen_significandxf2 (rtx, rtx);
extern rtx gen_significandsf2 (rtx, rtx);
extern rtx gen_significanddf2 (rtx, rtx);
extern rtx gen_rintsf2 (rtx, rtx);
extern rtx gen_rintdf2 (rtx, rtx);
extern rtx gen_nearbyintxf2 (rtx, rtx);
extern rtx gen_nearbyintsf2 (rtx, rtx);
extern rtx gen_nearbyintdf2 (rtx, rtx);
extern rtx gen_roundsf2 (rtx, rtx);
extern rtx gen_rounddf2 (rtx, rtx);
extern rtx gen_roundxf2 (rtx, rtx);
extern rtx gen_lrintsfsi2 (rtx, rtx);
extern rtx gen_lrintsfdi2 (rtx, rtx);
extern rtx gen_lrintdfsi2 (rtx, rtx);
extern rtx gen_lrintdfdi2 (rtx, rtx);
extern rtx gen_lroundsfhi2 (rtx, rtx);
extern rtx gen_lrounddfhi2 (rtx, rtx);
extern rtx gen_lroundxfhi2 (rtx, rtx);
extern rtx gen_lroundsfsi2 (rtx, rtx);
extern rtx gen_lrounddfsi2 (rtx, rtx);
extern rtx gen_lroundxfsi2 (rtx, rtx);
extern rtx gen_lroundsfdi2 (rtx, rtx);
extern rtx gen_lrounddfdi2 (rtx, rtx);
extern rtx gen_lroundxfdi2 (rtx, rtx);
extern rtx gen_roundevenxf2 (rtx, rtx);
extern rtx gen_floorxf2 (rtx, rtx);
extern rtx gen_ceilxf2 (rtx, rtx);
extern rtx gen_btruncxf2 (rtx, rtx);
extern rtx gen_roundevensf2 (rtx, rtx);
extern rtx gen_floorsf2 (rtx, rtx);
extern rtx gen_ceilsf2 (rtx, rtx);
extern rtx gen_btruncsf2 (rtx, rtx);
extern rtx gen_roundevendf2 (rtx, rtx);
extern rtx gen_floordf2 (rtx, rtx);
extern rtx gen_ceildf2 (rtx, rtx);
extern rtx gen_btruncdf2 (rtx, rtx);
extern rtx gen_lfloorxfhi2 (rtx, rtx);
extern rtx gen_lceilxfhi2 (rtx, rtx);
extern rtx gen_lfloorxfsi2 (rtx, rtx);
extern rtx gen_lceilxfsi2 (rtx, rtx);
extern rtx gen_lfloorxfdi2 (rtx, rtx);
extern rtx gen_lceilxfdi2 (rtx, rtx);
extern rtx gen_lfloorsfsi2 (rtx, rtx);
extern rtx gen_lceilsfsi2 (rtx, rtx);
extern rtx gen_lfloorsfdi2 (rtx, rtx);
extern rtx gen_lceilsfdi2 (rtx, rtx);
extern rtx gen_lfloordfsi2 (rtx, rtx);
extern rtx gen_lceildfsi2 (rtx, rtx);
extern rtx gen_lfloordfdi2 (rtx, rtx);
extern rtx gen_lceildfdi2 (rtx, rtx);
extern rtx gen_signbittf2 (rtx, rtx);
extern rtx gen_signbitxf2 (rtx, rtx);
extern rtx gen_signbitdf2 (rtx, rtx);
extern rtx gen_signbitsf2 (rtx, rtx);
extern rtx gen_cpymemsi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_cpymemdi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_strmov (rtx, rtx, rtx, rtx);
extern rtx gen_strmov_singleop (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_rep_mov (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_setmemsi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_setmemdi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_strset (rtx, rtx, rtx);
extern rtx gen_strset_singleop (rtx, rtx, rtx, rtx);
extern rtx gen_rep_stos (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_cmpstrnsi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_cmpintqi (rtx);
extern rtx gen_cmpstrnqi_nz_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_cmpstrnqi_1 (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_strlensi (rtx, rtx, rtx, rtx);
extern rtx gen_strlendi (rtx, rtx, rtx, rtx);
extern rtx gen_strlenqi_1 (rtx, rtx, rtx);
extern rtx gen_movqicc (rtx, rtx, rtx, rtx);
extern rtx gen_movhicc (rtx, rtx, rtx, rtx);
extern rtx gen_movsicc (rtx, rtx, rtx, rtx);
extern rtx gen_movdicc (rtx, rtx, rtx, rtx);
extern rtx gen_x86_movsicc_0_m1 (rtx, rtx, rtx);
extern rtx gen_x86_movdicc_0_m1 (rtx, rtx, rtx);
extern rtx gen_movsfcc (rtx, rtx, rtx, rtx);
extern rtx gen_movdfcc (rtx, rtx, rtx, rtx);
extern rtx gen_movxfcc (rtx, rtx, rtx, rtx);
extern rtx gen_addqicc (rtx, rtx, rtx, rtx);
extern rtx gen_addhicc (rtx, rtx, rtx, rtx);
extern rtx gen_addsicc (rtx, rtx, rtx, rtx);
extern rtx gen_adddicc (rtx, rtx, rtx, rtx);
extern rtx gen_smaxhi3 (rtx, rtx, rtx);
extern rtx gen_sminhi3 (rtx, rtx, rtx);
extern rtx gen_umaxhi3 (rtx, rtx, rtx);
extern rtx gen_uminhi3 (rtx, rtx, rtx);
extern rtx gen_smaxsi3 (rtx, rtx, rtx);
extern rtx gen_sminsi3 (rtx, rtx, rtx);
extern rtx gen_umaxsi3 (rtx, rtx, rtx);
extern rtx gen_uminsi3 (rtx, rtx, rtx);
extern rtx gen_smaxdi3 (rtx, rtx, rtx);
extern rtx gen_smindi3 (rtx, rtx, rtx);
extern rtx gen_umaxdi3 (rtx, rtx, rtx);
extern rtx gen_umindi3 (rtx, rtx, rtx);
extern rtx gen_allocate_stack (rtx, rtx);
extern rtx gen_probe_stack (rtx);
extern rtx gen_builtin_setjmp_receiver (rtx);
extern rtx gen_save_stack_nonlocal (rtx, rtx);
extern rtx gen_restore_stack_nonlocal (rtx, rtx);
extern rtx gen_prefetch (rtx, rtx, rtx);
extern rtx gen_stack_protect_set (rtx, rtx);
extern rtx gen_stack_protect_test (rtx, rtx, rtx);
extern rtx gen_pause (void);
extern rtx gen_xbegin (rtx);
extern rtx gen_xtest (rtx);
extern rtx gen_rdpkru (rtx);
extern rtx gen_wrpkru (rtx);
extern rtx gen_movv8qi (rtx, rtx);
extern rtx gen_movv4hi (rtx, rtx);
extern rtx gen_movv2si (rtx, rtx);
extern rtx gen_movv1di (rtx, rtx);
extern rtx gen_movv2sf (rtx, rtx);
extern rtx gen_movmisalignv8qi (rtx, rtx);
extern rtx gen_movmisalignv4hi (rtx, rtx);
extern rtx gen_movmisalignv2si (rtx, rtx);
extern rtx gen_movmisalignv1di (rtx, rtx);
extern rtx gen_movmisalignv2sf (rtx, rtx);
extern rtx gen_absv2sf2 (rtx, rtx);
extern rtx gen_negv2sf2 (rtx, rtx);
extern rtx gen_mmx_addv2sf3 (rtx, rtx, rtx);
extern rtx gen_addv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_subv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_subrv2sf3 (rtx, rtx, rtx);
extern rtx gen_subv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_mulv2sf3 (rtx, rtx, rtx);
extern rtx gen_mulv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_smaxv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_sminv2sf3 (rtx, rtx, rtx);
extern rtx gen_smaxv2sf3 (rtx, rtx, rtx);
extern rtx gen_sminv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_haddv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_haddsubv2sf3 (rtx, rtx, rtx);
extern rtx gen_mmx_eqv2sf3 (rtx, rtx, rtx);
extern rtx gen_copysignv2sf3 (rtx, rtx, rtx);
extern rtx gen_xorsignv2sf3 (rtx, rtx, rtx);
extern rtx gen_signbitv2sf2 (rtx, rtx);
extern rtx gen_fix_truncv2sfv2si2 (rtx, rtx);
extern rtx gen_floatv2siv2sf2 (rtx, rtx);
extern rtx gen_vec_setv2sf (rtx, rtx, rtx);
extern rtx gen_vec_extractv2sfsf (rtx, rtx, rtx);
extern rtx gen_vec_initv2sfsf (rtx, rtx);
extern rtx gen_mmx_addv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_subv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_addv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_subv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_addv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_subv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_addv1di3 (rtx, rtx, rtx);
extern rtx gen_mmx_subv1di3 (rtx, rtx, rtx);
extern rtx gen_addv8qi3 (rtx, rtx, rtx);
extern rtx gen_subv8qi3 (rtx, rtx, rtx);
extern rtx gen_addv4hi3 (rtx, rtx, rtx);
extern rtx gen_subv4hi3 (rtx, rtx, rtx);
extern rtx gen_addv2si3 (rtx, rtx, rtx);
extern rtx gen_subv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_ssaddv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_usaddv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_sssubv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_ussubv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_ssaddv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_usaddv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_sssubv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_ussubv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_mulv4hi3 (rtx, rtx, rtx);
extern rtx gen_mulv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_smulv4hi3_highpart (rtx, rtx, rtx);
extern rtx gen_mmx_umulv4hi3_highpart (rtx, rtx, rtx);
extern rtx gen_mmx_pmaddwd (rtx, rtx, rtx);
extern rtx gen_mmx_pmulhrwv4hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_umulv1siv1di3 (rtx, rtx, rtx);
extern rtx gen_mmx_smaxv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_sminv4hi3 (rtx, rtx, rtx);
extern rtx gen_smaxv4hi3 (rtx, rtx, rtx);
extern rtx gen_sminv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_umaxv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_uminv8qi3 (rtx, rtx, rtx);
extern rtx gen_umaxv8qi3 (rtx, rtx, rtx);
extern rtx gen_uminv8qi3 (rtx, rtx, rtx);
extern rtx gen_ashrv4hi3 (rtx, rtx, rtx);
extern rtx gen_ashrv2si3 (rtx, rtx, rtx);
extern rtx gen_ashlv4hi3 (rtx, rtx, rtx);
extern rtx gen_lshrv4hi3 (rtx, rtx, rtx);
extern rtx gen_ashlv2si3 (rtx, rtx, rtx);
extern rtx gen_lshrv2si3 (rtx, rtx, rtx);
extern rtx gen_ashlv1di3 (rtx, rtx, rtx);
extern rtx gen_lshrv1di3 (rtx, rtx, rtx);
extern rtx gen_mmx_eqv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_eqv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_eqv2si3 (rtx, rtx, rtx);
extern rtx gen_one_cmplv8qi2 (rtx, rtx);
extern rtx gen_one_cmplv4hi2 (rtx, rtx);
extern rtx gen_one_cmplv2si2 (rtx, rtx);
extern rtx gen_mmx_andv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_iorv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_xorv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_andv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_iorv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_xorv4hi3 (rtx, rtx, rtx);
extern rtx gen_mmx_andv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_iorv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_xorv2si3 (rtx, rtx, rtx);
extern rtx gen_andv8qi3 (rtx, rtx, rtx);
extern rtx gen_iorv8qi3 (rtx, rtx, rtx);
extern rtx gen_xorv8qi3 (rtx, rtx, rtx);
extern rtx gen_andv4hi3 (rtx, rtx, rtx);
extern rtx gen_iorv4hi3 (rtx, rtx, rtx);
extern rtx gen_xorv4hi3 (rtx, rtx, rtx);
extern rtx gen_andv2si3 (rtx, rtx, rtx);
extern rtx gen_iorv2si3 (rtx, rtx, rtx);
extern rtx gen_xorv2si3 (rtx, rtx, rtx);
extern rtx gen_mmx_pinsrw (rtx, rtx, rtx, rtx);
extern rtx gen_mmx_pshufw (rtx, rtx, rtx);
extern rtx gen_vec_setv2si (rtx, rtx, rtx);
extern rtx gen_vec_extractv2sisi (rtx, rtx, rtx);
extern rtx gen_vec_initv2sisi (rtx, rtx);
extern rtx gen_vec_setv4hi (rtx, rtx, rtx);
extern rtx gen_vec_extractv4hihi (rtx, rtx, rtx);
extern rtx gen_vec_initv4hihi (rtx, rtx);
extern rtx gen_vec_setv8qi (rtx, rtx, rtx);
extern rtx gen_vec_extractv8qiqi (rtx, rtx, rtx);
extern rtx gen_vec_initv8qiqi (rtx, rtx);
extern rtx gen_mmx_uavgv8qi3 (rtx, rtx, rtx);
extern rtx gen_mmx_uavgv4hi3 (rtx, rtx, rtx);
extern rtx gen_uavgv8qi3_ceil (rtx, rtx, rtx);
extern rtx gen_uavgv4hi3_ceil (rtx, rtx, rtx);
extern rtx gen_reduc_plus_scal_v8qi (rtx, rtx);
extern rtx gen_usadv8qi (rtx, rtx, rtx, rtx);
extern rtx gen_mmx_maskmovq (rtx, rtx, rtx);
extern rtx gen_mmx_emms (void);
extern rtx gen_mmx_femms (void);
extern rtx gen_movv64qi (rtx, rtx);
extern rtx gen_movv32qi (rtx, rtx);
extern rtx gen_movv16qi (rtx, rtx);
extern rtx gen_movv32hi (rtx, rtx);
extern rtx gen_movv16hi (rtx, rtx);
extern rtx gen_movv8hi (rtx, rtx);
extern rtx gen_movv16si (rtx, rtx);
extern rtx gen_movv8si (rtx, rtx);
extern rtx gen_movv4si (rtx, rtx);
extern rtx gen_movv8di (rtx, rtx);
extern rtx gen_movv4di (rtx, rtx);
extern rtx gen_movv2di (rtx, rtx);
extern rtx gen_movv4ti (rtx, rtx);
extern rtx gen_movv2ti (rtx, rtx);
extern rtx gen_movv1ti (rtx, rtx);
extern rtx gen_movv16sf (rtx, rtx);
extern rtx gen_movv8sf (rtx, rtx);
extern rtx gen_movv4sf (rtx, rtx);
extern rtx gen_movv8df (rtx, rtx);
extern rtx gen_movv4df (rtx, rtx);
extern rtx gen_movv2df (rtx, rtx);
extern rtx gen_avx512f_loadsf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_loaddf_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_blendmv16si (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv8si (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv4si (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_blendmv8di (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv4di (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv2di (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_blendmv16sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv8sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv4sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_blendmv8df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv4df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv2df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_blendmv64qi (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv16qi (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv32qi (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_blendmv32hi (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv16hi (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_blendmv8hi (rtx, rtx, rtx, rtx);
extern rtx gen_movmisalignv64qi (rtx, rtx);
extern rtx gen_movmisalignv32qi (rtx, rtx);
extern rtx gen_movmisalignv16qi (rtx, rtx);
extern rtx gen_movmisalignv32hi (rtx, rtx);
extern rtx gen_movmisalignv16hi (rtx, rtx);
extern rtx gen_movmisalignv8hi (rtx, rtx);
extern rtx gen_movmisalignv16si (rtx, rtx);
extern rtx gen_movmisalignv8si (rtx, rtx);
extern rtx gen_movmisalignv4si (rtx, rtx);
extern rtx gen_movmisalignv8di (rtx, rtx);
extern rtx gen_movmisalignv4di (rtx, rtx);
extern rtx gen_movmisalignv2di (rtx, rtx);
extern rtx gen_movmisalignv4ti (rtx, rtx);
extern rtx gen_movmisalignv2ti (rtx, rtx);
extern rtx gen_movmisalignv1ti (rtx, rtx);
extern rtx gen_movmisalignv16sf (rtx, rtx);
extern rtx gen_movmisalignv8sf (rtx, rtx);
extern rtx gen_movmisalignv4sf (rtx, rtx);
extern rtx gen_movmisalignv8df (rtx, rtx);
extern rtx gen_movmisalignv4df (rtx, rtx);
extern rtx gen_movmisalignv2df (rtx, rtx);
extern rtx gen_storentdi (rtx, rtx);
extern rtx gen_storentsi (rtx, rtx);
extern rtx gen_storentsf (rtx, rtx);
extern rtx gen_storentdf (rtx, rtx);
extern rtx gen_storentv8di (rtx, rtx);
extern rtx gen_storentv4di (rtx, rtx);
extern rtx gen_storentv2di (rtx, rtx);
extern rtx gen_storentv16sf (rtx, rtx);
extern rtx gen_storentv8sf (rtx, rtx);
extern rtx gen_storentv4sf (rtx, rtx);
extern rtx gen_storentv8df (rtx, rtx);
extern rtx gen_storentv4df (rtx, rtx);
extern rtx gen_storentv2df (rtx, rtx);
extern rtx gen_kmovb (rtx, rtx);
extern rtx gen_kmovw (rtx, rtx);
extern rtx gen_kmovd (rtx, rtx);
extern rtx gen_kmovq (rtx, rtx);
extern rtx gen_absv16sf2 (rtx, rtx);
extern rtx gen_negv16sf2 (rtx, rtx);
extern rtx gen_absv8sf2 (rtx, rtx);
extern rtx gen_negv8sf2 (rtx, rtx);
extern rtx gen_absv4sf2 (rtx, rtx);
extern rtx gen_negv4sf2 (rtx, rtx);
extern rtx gen_absv8df2 (rtx, rtx);
extern rtx gen_negv8df2 (rtx, rtx);
extern rtx gen_absv4df2 (rtx, rtx);
extern rtx gen_negv4df2 (rtx, rtx);
extern rtx gen_absv2df2 (rtx, rtx);
extern rtx gen_negv2df2 (rtx, rtx);
extern rtx gen_addv16sf3 (rtx, rtx, rtx);
extern rtx gen_addv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_addv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv16sf3 (rtx, rtx, rtx);
extern rtx gen_subv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_subv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv8sf3 (rtx, rtx, rtx);
static inline rtx gen_addv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_addv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_addv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_addv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv8sf3 (rtx, rtx, rtx);
static inline rtx gen_subv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_subv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_subv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_subv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv4sf3 (rtx, rtx, rtx);
static inline rtx gen_addv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_addv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_addv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_addv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv4sf3 (rtx, rtx, rtx);
static inline rtx gen_subv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_subv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_subv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_subv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv8df3 (rtx, rtx, rtx);
extern rtx gen_addv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_addv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv8df3 (rtx, rtx, rtx);
extern rtx gen_subv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_subv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv4df3 (rtx, rtx, rtx);
static inline rtx gen_addv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_addv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_addv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_addv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv4df3 (rtx, rtx, rtx);
static inline rtx gen_subv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_subv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_subv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_subv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv2df3 (rtx, rtx, rtx);
static inline rtx gen_addv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_addv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_addv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_addv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_addv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv2df3 (rtx, rtx, rtx);
static inline rtx gen_subv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_subv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_subv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_subv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_subv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv16sf3 (rtx, rtx, rtx);
extern rtx gen_mulv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_mulv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv8sf3 (rtx, rtx, rtx);
static inline rtx gen_mulv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_mulv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv4sf3 (rtx, rtx, rtx);
static inline rtx gen_mulv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_mulv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv8df3 (rtx, rtx, rtx);
extern rtx gen_mulv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_mulv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv4df3 (rtx, rtx, rtx);
static inline rtx gen_mulv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_mulv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv2df3 (rtx, rtx, rtx);
static inline rtx gen_mulv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_mulv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_mulv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_mulv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_divv8df3 (rtx, rtx, rtx);
extern rtx gen_divv4df3 (rtx, rtx, rtx);
extern rtx gen_divv2df3 (rtx, rtx, rtx);
extern rtx gen_divv16sf3 (rtx, rtx, rtx);
extern rtx gen_divv8sf3 (rtx, rtx, rtx);
extern rtx gen_divv4sf3 (rtx, rtx, rtx);
extern rtx gen_sqrtv8df2 (rtx, rtx);
extern rtx gen_sqrtv4df2 (rtx, rtx);
extern rtx gen_sqrtv2df2 (rtx, rtx);
extern rtx gen_sqrtv16sf2 (rtx, rtx);
extern rtx gen_sqrtv8sf2 (rtx, rtx);
extern rtx gen_sqrtv4sf2 (rtx, rtx);
extern rtx gen_rsqrtv16sf2 (rtx, rtx);
extern rtx gen_rsqrtv8sf2 (rtx, rtx);
extern rtx gen_rsqrtv4sf2 (rtx, rtx);
extern rtx gen_smaxv16sf3 (rtx, rtx, rtx);
extern rtx gen_smaxv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_smaxv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv16sf3 (rtx, rtx, rtx);
extern rtx gen_sminv16sf3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sminv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv16sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8sf3 (rtx, rtx, rtx);
static inline rtx gen_smaxv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_smaxv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv8sf3 (rtx, rtx, rtx);
static inline rtx gen_sminv8sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv8sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_sminv8sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv8sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv4sf3 (rtx, rtx, rtx);
static inline rtx gen_smaxv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_smaxv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv4sf3 (rtx, rtx, rtx);
static inline rtx gen_sminv4sf3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv4sf3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_sminv4sf3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv4sf3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv8df3 (rtx, rtx, rtx);
extern rtx gen_smaxv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv8df3 (rtx, rtx, rtx);
extern rtx gen_sminv8df3_round (rtx, rtx, rtx, rtx);
extern rtx gen_sminv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv8df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv4df3 (rtx, rtx, rtx);
static inline rtx gen_smaxv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_smaxv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv4df3 (rtx, rtx, rtx);
static inline rtx gen_sminv4df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv4df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv4df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_sminv4df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv4df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv2df3 (rtx, rtx, rtx);
static inline rtx gen_smaxv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_smaxv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_smaxv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_smaxv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv2df3 (rtx, rtx, rtx);
static inline rtx gen_sminv2df3_round (rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv2df3_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sminv2df3_mask (rtx, rtx, rtx, rtx, rtx);
static inline rtx gen_sminv2df3_mask_round (rtx, rtx, rtx, rtx, rtx, rtx);
static inline rtx
gen_sminv2df3_mask_round(rtx a __attribute__ ((__unused__)), rtx b __attribute__ ((__unused__)), rtx c __attribute__ ((__unused__)), rtx d __attribute__ ((__unused__)), rtx e __attribute__ ((__unused__)), rtx f __attribute__ ((__unused__)))
{
return 0;
}
extern rtx gen_sse3_haddv2df3 (rtx, rtx, rtx);
extern rtx gen_reduc_plus_scal_v2df (rtx, rtx);
extern rtx gen_reduc_plus_scal_v4sf (rtx, rtx);
extern rtx gen_reduc_plus_scal_v16qi (rtx, rtx);
extern rtx gen_reduc_plus_scal_v4df (rtx, rtx);
extern rtx gen_reduc_plus_scal_v8sf (rtx, rtx);
extern rtx gen_reduc_plus_scal_v8df (rtx, rtx);
extern rtx gen_reduc_plus_scal_v16sf (rtx, rtx);
extern rtx gen_reduc_plus_scal_v32qi (rtx, rtx);
extern rtx gen_reduc_plus_scal_v64qi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v4sf (rtx, rtx);
extern rtx gen_reduc_smin_scal_v4sf (rtx, rtx);
extern rtx gen_reduc_smax_scal_v2df (rtx, rtx);
extern rtx gen_reduc_smin_scal_v2df (rtx, rtx);
extern rtx gen_reduc_smax_scal_v4si (rtx, rtx);
extern rtx gen_reduc_smin_scal_v4si (rtx, rtx);
extern rtx gen_reduc_smax_scal_v8hi (rtx, rtx);
extern rtx gen_reduc_smin_scal_v8hi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v16qi (rtx, rtx);
extern rtx gen_reduc_smin_scal_v16qi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v2di (rtx, rtx);
extern rtx gen_reduc_smin_scal_v2di (rtx, rtx);
extern rtx gen_reduc_smax_scal_v32qi (rtx, rtx);
extern rtx gen_reduc_smin_scal_v32qi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v16hi (rtx, rtx);
extern rtx gen_reduc_smin_scal_v16hi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v8si (rtx, rtx);
extern rtx gen_reduc_smin_scal_v8si (rtx, rtx);
extern rtx gen_reduc_smax_scal_v4di (rtx, rtx);
extern rtx gen_reduc_smin_scal_v4di (rtx, rtx);
extern rtx gen_reduc_smax_scal_v8sf (rtx, rtx);
extern rtx gen_reduc_smin_scal_v8sf (rtx, rtx);
extern rtx gen_reduc_smax_scal_v4df (rtx, rtx);
extern rtx gen_reduc_smin_scal_v4df (rtx, rtx);
extern rtx gen_reduc_smax_scal_v64qi (rtx, rtx);
extern rtx gen_reduc_smin_scal_v64qi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v32hi (rtx, rtx);
extern rtx gen_reduc_smin_scal_v32hi (rtx, rtx);
extern rtx gen_reduc_smax_scal_v16si (rtx, rtx);
extern rtx gen_reduc_smin_scal_v16si (rtx, rtx);
extern rtx gen_reduc_smax_scal_v8di (rtx, rtx);
extern rtx gen_reduc_smin_scal_v8di (rtx, rtx);
extern rtx gen_reduc_smax_scal_v16sf (rtx, rtx);
extern rtx gen_reduc_smin_scal_v16sf (rtx, rtx);
extern rtx gen_reduc_smax_scal_v8df (rtx, rtx);
extern rtx gen_reduc_smin_scal_v8df (rtx, rtx);
extern rtx gen_reduc_umax_scal_v16si (rtx, rtx);
extern rtx gen_reduc_umin_scal_v16si (rtx, rtx);
extern rtx gen_reduc_umax_scal_v8di (rtx, rtx);
extern rtx gen_reduc_umin_scal_v8di (rtx, rtx);
extern rtx gen_reduc_umax_scal_v32hi (rtx, rtx);
extern rtx gen_reduc_umin_scal_v32hi (rtx, rtx);
extern rtx gen_reduc_umax_scal_v64qi (rtx, rtx);
extern rtx gen_reduc_umin_scal_v64qi (rtx, rtx);
extern rtx gen_reduc_umax_scal_v32qi (rtx, rtx);
extern rtx gen_reduc_umin_scal_v32qi (rtx, rtx);
extern rtx gen_reduc_umax_scal_v16hi (rtx, rtx);
extern rtx gen_reduc_umin_scal_v16hi (rtx, rtx);
extern rtx gen_reduc_umax_scal_v8si (rtx, rtx);
extern rtx gen_reduc_umin_scal_v8si (rtx, rtx);
extern rtx gen_reduc_umax_scal_v4di (rtx, rtx);
extern rtx gen_reduc_umin_scal_v4di (rtx, rtx);
extern rtx gen_reduc_umin_scal_v8hi (rtx, rtx);
extern rtx gen_vec_cmpv16sihi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8siqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4siqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv2diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv16sfhi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8sfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4sfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8dfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4dfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv2dfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv64qidi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv16qihi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv32qisi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv32hisi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv16hihi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8hiqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv32qiv32qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv16hiv16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8siv8si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4div4di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv16qiv16qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8hiv8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4siv4si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv2div2di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv8sfv8si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4dfv4di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv4sfv4si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpv2dfv2di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv16sihi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv8siqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv4siqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv8diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv4diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv2diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv64qidi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv16qihi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv32qisi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv32hisi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv16hihi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv8hiqi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv32qiv32qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv16hiv16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv8siv8si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv4div4di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv16qiv16qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv8hiv8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv4siv4si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpuv2div2di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_cmpeqv2div2di (rtx, rtx, rtx, rtx);
extern rtx gen_vcondv64qiv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32hiv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16siv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8div16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16sfv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8dfv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv64qiv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32hiv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16siv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8div8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16sfv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8dfv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32qiv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16hiv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8siv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4div8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8sfv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4dfv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32qiv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16hiv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8siv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4div4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8sfv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4dfv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16qiv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16qiv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8hiv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8hiv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4siv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4siv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2div4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2div2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4sfv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4sfv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2dfv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2dfv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v16sihi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8siqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4siqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v2diqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v16sfhi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8sfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4sfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8dfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4dfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v2dfqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v64qidi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v16qihi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v32qisi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v32hisi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v16hihi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8hiqi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v32qiv32qi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v16hiv16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8siv8si (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4div4di (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v16qiv16qi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8hiv8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4siv4si (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v2div2di (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v8sfv8si (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4dfv4di (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v4sfv4si (rtx, rtx, rtx, rtx);
extern rtx gen_vcond_mask_v2dfv2di (rtx, rtx, rtx, rtx);
extern rtx gen_andv8sf3 (rtx, rtx, rtx);
extern rtx gen_andv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv8sf3 (rtx, rtx, rtx);
extern rtx gen_iorv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv8sf3 (rtx, rtx, rtx);
extern rtx gen_xorv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv4sf3 (rtx, rtx, rtx);
extern rtx gen_andv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv4sf3 (rtx, rtx, rtx);
extern rtx gen_iorv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv4sf3 (rtx, rtx, rtx);
extern rtx gen_xorv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv4df3 (rtx, rtx, rtx);
extern rtx gen_andv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv4df3 (rtx, rtx, rtx);
extern rtx gen_iorv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv4df3 (rtx, rtx, rtx);
extern rtx gen_xorv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv2df3 (rtx, rtx, rtx);
extern rtx gen_andv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv2df3 (rtx, rtx, rtx);
extern rtx gen_iorv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv2df3 (rtx, rtx, rtx);
extern rtx gen_xorv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv16sf3 (rtx, rtx, rtx);
extern rtx gen_andv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv16sf3 (rtx, rtx, rtx);
extern rtx gen_iorv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv16sf3 (rtx, rtx, rtx);
extern rtx gen_xorv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv8df3 (rtx, rtx, rtx);
extern rtx gen_andv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_iorv8df3 (rtx, rtx, rtx);
extern rtx gen_iorv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_xorv8df3 (rtx, rtx, rtx);
extern rtx gen_xorv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_copysignv16sf3 (rtx, rtx, rtx);
extern rtx gen_copysignv8sf3 (rtx, rtx, rtx);
extern rtx gen_copysignv4sf3 (rtx, rtx, rtx);
extern rtx gen_copysignv8df3 (rtx, rtx, rtx);
extern rtx gen_copysignv4df3 (rtx, rtx, rtx);
extern rtx gen_copysignv2df3 (rtx, rtx, rtx);
extern rtx gen_xorsignv16sf3 (rtx, rtx, rtx);
extern rtx gen_xorsignv8sf3 (rtx, rtx, rtx);
extern rtx gen_xorsignv4sf3 (rtx, rtx, rtx);
extern rtx gen_xorsignv8df3 (rtx, rtx, rtx);
extern rtx gen_xorsignv4df3 (rtx, rtx, rtx);
extern rtx gen_xorsignv2df3 (rtx, rtx, rtx);
extern rtx gen_signbitv16sf2 (rtx, rtx);
extern rtx gen_signbitv8sf2 (rtx, rtx);
extern rtx gen_signbitv4sf2 (rtx, rtx);
extern rtx gen_andtf3 (rtx, rtx, rtx);
extern rtx gen_iortf3 (rtx, rtx, rtx);
extern rtx gen_xortf3 (rtx, rtx, rtx);
extern rtx gen_fmasf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmadf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmav4sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmav2df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmav8sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmav4df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmav16sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmav8df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmssf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsdf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv4sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv2df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv8sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv4df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv16sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fmsv8df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmasf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmadf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav4sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav2df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav8sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav4df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav16sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmav8df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmssf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsdf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv4sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv2df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv8sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv4df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv16sf4 (rtx, rtx, rtx, rtx);
extern rtx gen_fnmsv8df4 (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_v4df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_v16sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmadd_v8df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_v4df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_v16sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fmsub_v8df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_v4df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_v16sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmadd_v8df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_v4df (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_v16sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_fnmsub_v8df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v16sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v16sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v8sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v8sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v8df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmadd_v8df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v4df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v2df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmadd_v2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v16sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v16sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v8sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v8sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v8df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmsub_v8df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v4df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v2df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmsub_v2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v16sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v16sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v8sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v8sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v8df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmadd_v8df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v4df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v4df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v2df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmadd_v2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v16sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v16sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v8sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v8sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v8df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fnmsub_v8df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v4df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v2df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fnmsub_v2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmaddsub_v16sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmaddsub_v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmaddsub_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmaddsub_v8df (rtx, rtx, rtx, rtx);
extern rtx gen_fmaddsub_v4df (rtx, rtx, rtx, rtx);
extern rtx gen_fmaddsub_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v16sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v16sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v8sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v8sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v8df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fmaddsub_v8df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v4df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v2df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fmaddsub_v2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmadd_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmadd_v4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmadd_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmadd_v2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmsub_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmsub_v4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmsub_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfmsub_v2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmadd_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmadd_v4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmadd_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmadd_v2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmsub_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmsub_v4sf_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmsub_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_fmai_vmfnmsub_v2df_round (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vmfmadd_v2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_vmfmadd_v4sf (rtx, rtx, rtx, rtx);
extern rtx gen_fma4i_vmfmadd_v2df (rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv16siv16sf2 (rtx, rtx);
extern rtx gen_floatunsv8siv8sf2 (rtx, rtx);
extern rtx gen_floatunsv4siv4sf2 (rtx, rtx);
extern rtx gen_fixuns_truncv16sfv16si2 (rtx, rtx);
extern rtx gen_fixuns_truncv8sfv8si2 (rtx, rtx);
extern rtx gen_fixuns_truncv4sfv4si2 (rtx, rtx);
extern rtx gen_floatv2siv2df2 (rtx, rtx);
extern rtx gen_fix_truncv2dfv2si2 (rtx, rtx);
extern rtx gen_avx512dq_floatv2div2sf2 (rtx, rtx);
extern rtx gen_avx512dq_floatunsv2div2sf2 (rtx, rtx);
extern rtx gen_floatv2div2sf2 (rtx, rtx);
extern rtx gen_floatunsv2div2sf2 (rtx, rtx);
extern rtx gen_vec_packs_float_v8di (rtx, rtx, rtx);
extern rtx gen_vec_packu_float_v8di (rtx, rtx, rtx);
extern rtx gen_vec_packs_float_v4di (rtx, rtx, rtx);
extern rtx gen_vec_packu_float_v4di (rtx, rtx, rtx);
extern rtx gen_vec_packs_float_v2di (rtx, rtx, rtx);
extern rtx gen_vec_packu_float_v2di (rtx, rtx, rtx);
extern rtx gen_floatv2div2sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_floatunsv2div2sf2_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx_cvtpd2dq256_2 (rtx, rtx);
extern rtx gen_fix_truncv2sfv2di2 (rtx, rtx);
extern rtx gen_fixuns_truncv2sfv2di2 (rtx, rtx);
extern rtx gen_vec_unpack_sfix_trunc_lo_v16sf (rtx, rtx);
extern rtx gen_vec_unpack_ufix_trunc_lo_v16sf (rtx, rtx);
extern rtx gen_vec_unpack_sfix_trunc_lo_v8sf (rtx, rtx);
extern rtx gen_vec_unpack_ufix_trunc_lo_v8sf (rtx, rtx);
extern rtx gen_vec_unpack_sfix_trunc_lo_v4sf (rtx, rtx);
extern rtx gen_vec_unpack_ufix_trunc_lo_v4sf (rtx, rtx);
extern rtx gen_vec_unpack_sfix_trunc_hi_v16sf (rtx, rtx);
extern rtx gen_vec_unpack_ufix_trunc_hi_v16sf (rtx, rtx);
extern rtx gen_vec_unpack_sfix_trunc_hi_v8sf (rtx, rtx);
extern rtx gen_vec_unpack_ufix_trunc_hi_v8sf (rtx, rtx);
extern rtx gen_vec_unpack_sfix_trunc_hi_v4sf (rtx, rtx);
extern rtx gen_vec_unpack_ufix_trunc_hi_v4sf (rtx, rtx);
extern rtx gen_avx_cvttpd2dq256_2 (rtx, rtx);
extern rtx gen_sse2_cvtpd2ps (rtx, rtx);
extern rtx gen_sse2_cvtpd2ps_mask (rtx, rtx, rtx, rtx);
extern rtx gen_truncv8dfv8sf2 (rtx, rtx);
extern rtx gen_truncv4dfv4sf2 (rtx, rtx);
extern rtx gen_extendv8sfv8df2 (rtx, rtx);
extern rtx gen_extendv4sfv4df2 (rtx, rtx);
extern rtx gen_avx512bw_cvtmask2bv64qi (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2bv16qi (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2bv32qi (rtx, rtx);
extern rtx gen_avx512bw_cvtmask2wv32hi (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2wv16hi (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2wv8hi (rtx, rtx);
extern rtx gen_avx512f_cvtmask2dv16si (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2dv8si (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2dv4si (rtx, rtx);
extern rtx gen_avx512f_cvtmask2qv8di (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2qv4di (rtx, rtx);
extern rtx gen_avx512vl_cvtmask2qv2di (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v4sf (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v8sf (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v16sf (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v4sf (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v8sf (rtx, rtx);
extern rtx gen_vec_unpacks_float_hi_v32hi (rtx, rtx);
extern rtx gen_vec_unpacks_float_hi_v16hi (rtx, rtx);
extern rtx gen_vec_unpacks_float_hi_v8hi (rtx, rtx);
extern rtx gen_vec_unpacks_float_lo_v32hi (rtx, rtx);
extern rtx gen_vec_unpacks_float_lo_v16hi (rtx, rtx);
extern rtx gen_vec_unpacks_float_lo_v8hi (rtx, rtx);
extern rtx gen_vec_unpacku_float_hi_v32hi (rtx, rtx);
extern rtx gen_vec_unpacku_float_hi_v16hi (rtx, rtx);
extern rtx gen_vec_unpacku_float_hi_v8hi (rtx, rtx);
extern rtx gen_vec_unpacku_float_lo_v32hi (rtx, rtx);
extern rtx gen_vec_unpacku_float_lo_v16hi (rtx, rtx);
extern rtx gen_vec_unpacku_float_lo_v8hi (rtx, rtx);
extern rtx gen_vec_unpacks_float_hi_v4si (rtx, rtx);
extern rtx gen_vec_unpacks_float_lo_v4si (rtx, rtx);
extern rtx gen_vec_unpacks_float_hi_v8si (rtx, rtx);
extern rtx gen_vec_unpacks_float_lo_v8si (rtx, rtx);
extern rtx gen_vec_unpacks_float_hi_v16si (rtx, rtx);
extern rtx gen_vec_unpacks_float_lo_v16si (rtx, rtx);
extern rtx gen_vec_unpacku_float_hi_v4si (rtx, rtx);
extern rtx gen_vec_unpacku_float_lo_v4si (rtx, rtx);
extern rtx gen_vec_unpacku_float_hi_v8si (rtx, rtx);
extern rtx gen_vec_unpacku_float_hi_v16si (rtx, rtx);
extern rtx gen_vec_unpacku_float_lo_v8si (rtx, rtx);
extern rtx gen_vec_unpacku_float_lo_v16si (rtx, rtx);
extern rtx gen_vec_pack_trunc_v8df (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v4df (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v2df (rtx, rtx, rtx);
extern rtx gen_vec_pack_sfix_trunc_v8df (rtx, rtx, rtx);
extern rtx gen_vec_pack_sfix_trunc_v4df (rtx, rtx, rtx);
extern rtx gen_vec_pack_sfix_trunc_v2df (rtx, rtx, rtx);
extern rtx gen_vec_pack_ufix_trunc_v8df (rtx, rtx, rtx);
extern rtx gen_vec_pack_ufix_trunc_v4df (rtx, rtx, rtx);
extern rtx gen_vec_pack_ufix_trunc_v2df (rtx, rtx, rtx);
extern rtx gen_avx512f_vec_pack_sfix_v8df (rtx, rtx, rtx);
extern rtx gen_vec_pack_sfix_v4df (rtx, rtx, rtx);
extern rtx gen_vec_pack_sfix_v2df (rtx, rtx, rtx);
extern rtx gen_sse_movhlps_exp (rtx, rtx, rtx);
extern rtx gen_sse_movlhps_exp (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv8sf (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv8sf (rtx, rtx, rtx);
extern rtx gen_avx_shufps256 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufps256_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_shufps (rtx, rtx, rtx, rtx);
extern rtx gen_sse_shufps_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse_loadhps_exp (rtx, rtx, rtx);
extern rtx gen_sse_loadlps_exp (rtx, rtx, rtx);
extern rtx gen_vec_setv64qi (rtx, rtx, rtx);
extern rtx gen_vec_setv32qi (rtx, rtx, rtx);
extern rtx gen_vec_setv16qi (rtx, rtx, rtx);
extern rtx gen_vec_setv32hi (rtx, rtx, rtx);
extern rtx gen_vec_setv16hi (rtx, rtx, rtx);
extern rtx gen_vec_setv8hi (rtx, rtx, rtx);
extern rtx gen_vec_setv16si (rtx, rtx, rtx);
extern rtx gen_vec_setv8si (rtx, rtx, rtx);
extern rtx gen_vec_setv4si (rtx, rtx, rtx);
extern rtx gen_vec_setv8di (rtx, rtx, rtx);
extern rtx gen_vec_setv4di (rtx, rtx, rtx);
extern rtx gen_vec_setv2di (rtx, rtx, rtx);
extern rtx gen_vec_setv16sf (rtx, rtx, rtx);
extern rtx gen_vec_setv8sf (rtx, rtx, rtx);
extern rtx gen_vec_setv4sf (rtx, rtx, rtx);
extern rtx gen_vec_setv8df (rtx, rtx, rtx);
extern rtx gen_vec_setv4df (rtx, rtx, rtx);
extern rtx gen_vec_setv2df (rtx, rtx, rtx);
extern rtx gen_avx512dq_vextractf64x2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vextracti64x2_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vextractf32x4_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vextracti32x4_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vextractf32x8_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vextracti32x8_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vextractf64x4_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vextracti64x4_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vextractf128v8si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vextractf128v8sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vextractf128v4di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vextractf128v4df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vextractf128v32qi (rtx, rtx, rtx);
extern rtx gen_avx_vextractf128v16hi (rtx, rtx, rtx);
extern rtx gen_avx_vextractf128v8si (rtx, rtx, rtx);
extern rtx gen_avx_vextractf128v4di (rtx, rtx, rtx);
extern rtx gen_avx_vextractf128v8sf (rtx, rtx, rtx);
extern rtx gen_avx_vextractf128v4df (rtx, rtx, rtx);
extern rtx gen_vec_extractv64qiqi (rtx, rtx, rtx);
extern rtx gen_vec_extractv32qiqi (rtx, rtx, rtx);
extern rtx gen_vec_extractv16qiqi (rtx, rtx, rtx);
extern rtx gen_vec_extractv32hihi (rtx, rtx, rtx);
extern rtx gen_vec_extractv16hihi (rtx, rtx, rtx);
extern rtx gen_vec_extractv8hihi (rtx, rtx, rtx);
extern rtx gen_vec_extractv16sisi (rtx, rtx, rtx);
extern rtx gen_vec_extractv8sisi (rtx, rtx, rtx);
extern rtx gen_vec_extractv4sisi (rtx, rtx, rtx);
extern rtx gen_vec_extractv8didi (rtx, rtx, rtx);
extern rtx gen_vec_extractv4didi (rtx, rtx, rtx);
extern rtx gen_vec_extractv2didi (rtx, rtx, rtx);
extern rtx gen_vec_extractv16sfsf (rtx, rtx, rtx);
extern rtx gen_vec_extractv8sfsf (rtx, rtx, rtx);
extern rtx gen_vec_extractv4sfsf (rtx, rtx, rtx);
extern rtx gen_vec_extractv8dfdf (rtx, rtx, rtx);
extern rtx gen_vec_extractv4dfdf (rtx, rtx, rtx);
extern rtx gen_vec_extractv2dfdf (rtx, rtx, rtx);
extern rtx gen_vec_extractv4titi (rtx, rtx, rtx);
extern rtx gen_vec_extractv2titi (rtx, rtx, rtx);
extern rtx gen_vec_extractv32qiv16qi (rtx, rtx, rtx);
extern rtx gen_vec_extractv16hiv8hi (rtx, rtx, rtx);
extern rtx gen_vec_extractv8siv4si (rtx, rtx, rtx);
extern rtx gen_vec_extractv4div2di (rtx, rtx, rtx);
extern rtx gen_vec_extractv8sfv4sf (rtx, rtx, rtx);
extern rtx gen_vec_extractv4dfv2df (rtx, rtx, rtx);
extern rtx gen_vec_extractv64qiv32qi (rtx, rtx, rtx);
extern rtx gen_vec_extractv32hiv16hi (rtx, rtx, rtx);
extern rtx gen_vec_extractv16siv8si (rtx, rtx, rtx);
extern rtx gen_vec_extractv8div4di (rtx, rtx, rtx);
extern rtx gen_vec_extractv16sfv8sf (rtx, rtx, rtx);
extern rtx gen_vec_extractv8dfv4df (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv4df (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv2df (rtx, rtx, rtx);
extern rtx gen_avx512f_movddup512 (rtx, rtx);
extern rtx gen_avx512f_movddup512_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_unpcklpd512 (rtx, rtx, rtx);
extern rtx gen_avx512f_unpcklpd512_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_movddup256 (rtx, rtx);
extern rtx gen_avx_movddup256_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx_unpcklpd256 (rtx, rtx, rtx);
extern rtx gen_avx_unpcklpd256_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv4df (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv2df (rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv16si_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv8si_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4si_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vternlogv8di_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv4di_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vternlogv2di_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shufps512_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv16sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv8sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_fixupimmv8df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv4df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_fixupimmv2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv4sf_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_maskz (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_sfixupimmv2df_maskz_round (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shufpd512_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufpd256 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_shufpd256_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_shufpd (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_shufpd_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_loadhpd_exp (rtx, rtx, rtx);
extern rtx gen_sse2_loadlpd_exp (rtx, rtx, rtx);
extern rtx gen_truncv16siv16qi2 (rtx, rtx);
extern rtx gen_truncv16siv16hi2 (rtx, rtx);
extern rtx gen_truncv8div8si2 (rtx, rtx);
extern rtx gen_truncv8div8hi2 (rtx, rtx);
extern rtx gen_avx512f_ss_truncatev16siv16qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev16siv16qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev16siv16qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev16siv16hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev16siv16hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev16siv16hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div8si2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev8div8si2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div8si2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_ss_truncatev8div8hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_truncatev8div8hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512f_us_truncatev8div8hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_truncv32hiv32qi2 (rtx, rtx);
extern rtx gen_avx512bw_ss_truncatev32hiv32qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512bw_truncatev32hiv32qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512bw_us_truncatev32hiv32qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_truncv4div4si2 (rtx, rtx);
extern rtx gen_truncv8siv8hi2 (rtx, rtx);
extern rtx gen_truncv16hiv16qi2 (rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev4div4si2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev4div4si2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev4div4si2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev8siv8hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev8siv8hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev8siv8hi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_ss_truncatev16hiv16qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_truncatev16hiv16qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_avx512vl_us_truncatev16hiv16qi2_mask_store (rtx, rtx, rtx);
extern rtx gen_truncv4div4qi2 (rtx, rtx);
extern rtx gen_truncv2div2qi2 (rtx, rtx);
extern rtx gen_truncv8siv8qi2 (rtx, rtx);
extern rtx gen_truncv4siv4qi2 (rtx, rtx);
extern rtx gen_truncv8hiv8qi2 (rtx, rtx);
extern rtx gen_truncv4diV4HI2 (rtx, rtx);
extern rtx gen_truncv2diV2HI2 (rtx, rtx);
extern rtx gen_truncv4siV4HI2 (rtx, rtx);
extern rtx gen_truncv2div2si2 (rtx, rtx);
extern rtx gen_truncv8div8qi2 (rtx, rtx);
extern rtx gen_negv64qi2 (rtx, rtx);
extern rtx gen_negv32qi2 (rtx, rtx);
extern rtx gen_negv16qi2 (rtx, rtx);
extern rtx gen_negv32hi2 (rtx, rtx);
extern rtx gen_negv16hi2 (rtx, rtx);
extern rtx gen_negv8hi2 (rtx, rtx);
extern rtx gen_negv16si2 (rtx, rtx);
extern rtx gen_negv8si2 (rtx, rtx);
extern rtx gen_negv4si2 (rtx, rtx);
extern rtx gen_negv8di2 (rtx, rtx);
extern rtx gen_negv4di2 (rtx, rtx);
extern rtx gen_negv2di2 (rtx, rtx);
extern rtx gen_addv64qi3 (rtx, rtx, rtx);
extern rtx gen_subv64qi3 (rtx, rtx, rtx);
extern rtx gen_addv32qi3 (rtx, rtx, rtx);
extern rtx gen_subv32qi3 (rtx, rtx, rtx);
extern rtx gen_addv16qi3 (rtx, rtx, rtx);
extern rtx gen_subv16qi3 (rtx, rtx, rtx);
extern rtx gen_addv32hi3 (rtx, rtx, rtx);
extern rtx gen_subv32hi3 (rtx, rtx, rtx);
extern rtx gen_addv16hi3 (rtx, rtx, rtx);
extern rtx gen_subv16hi3 (rtx, rtx, rtx);
extern rtx gen_addv8hi3 (rtx, rtx, rtx);
extern rtx gen_subv8hi3 (rtx, rtx, rtx);
extern rtx gen_addv16si3 (rtx, rtx, rtx);
extern rtx gen_subv16si3 (rtx, rtx, rtx);
extern rtx gen_addv8si3 (rtx, rtx, rtx);
extern rtx gen_subv8si3 (rtx, rtx, rtx);
extern rtx gen_addv4si3 (rtx, rtx, rtx);
extern rtx gen_subv4si3 (rtx, rtx, rtx);
extern rtx gen_addv8di3 (rtx, rtx, rtx);
extern rtx gen_subv8di3 (rtx, rtx, rtx);
extern rtx gen_addv4di3 (rtx, rtx, rtx);
extern rtx gen_subv4di3 (rtx, rtx, rtx);
extern rtx gen_addv2di3 (rtx, rtx, rtx);
extern rtx gen_subv2di3 (rtx, rtx, rtx);
extern rtx gen_addv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_addv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_subv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ssaddv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_ssaddv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_usaddv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_usaddv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_sssubv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_sssubv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ussubv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_ussubv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ssaddv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_ssaddv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_usaddv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_usaddv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sssubv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_sssubv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ussubv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_ussubv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_ssaddv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_ssaddv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_usaddv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_usaddv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_sssubv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_sssubv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_ussubv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_ussubv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ssaddv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_ssaddv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_usaddv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_usaddv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_sssubv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_sssubv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_ussubv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_ussubv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ssaddv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_ssaddv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_usaddv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_usaddv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_sssubv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_sssubv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_ussubv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_ussubv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_ssaddv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_ssaddv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_usaddv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_usaddv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_sssubv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_sssubv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_ussubv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_ussubv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv8qi3 (rtx, rtx, rtx);
extern rtx gen_mulv64qi3 (rtx, rtx, rtx);
extern rtx gen_mulv32qi3 (rtx, rtx, rtx);
extern rtx gen_mulv16qi3 (rtx, rtx, rtx);
extern rtx gen_mulv32hi3 (rtx, rtx, rtx);
extern rtx gen_mulv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv16hi3 (rtx, rtx, rtx);
extern rtx gen_mulv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv8hi3 (rtx, rtx, rtx);
extern rtx gen_mulv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smulv32hi3_highpart (rtx, rtx, rtx);
extern rtx gen_smulv32hi3_highpart_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umulv32hi3_highpart (rtx, rtx, rtx);
extern rtx gen_umulv32hi3_highpart_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smulv16hi3_highpart (rtx, rtx, rtx);
extern rtx gen_smulv16hi3_highpart_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umulv16hi3_highpart (rtx, rtx, rtx);
extern rtx gen_umulv16hi3_highpart_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smulv8hi3_highpart (rtx, rtx, rtx);
extern rtx gen_smulv8hi3_highpart_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umulv8hi3_highpart (rtx, rtx, rtx);
extern rtx gen_umulv8hi3_highpart_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_even_v16si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_even_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_even_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_even_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_even_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_even_v4si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_even_v16si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_even_v16si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_even_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_even_v8si_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_mulv2siv2di3 (rtx, rtx, rtx);
extern rtx gen_sse4_1_mulv2siv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pmaddwd (rtx, rtx, rtx);
extern rtx gen_sse2_pmaddwd (rtx, rtx, rtx);
extern rtx gen_mulv16si3 (rtx, rtx, rtx);
extern rtx gen_mulv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv8si3 (rtx, rtx, rtx);
extern rtx gen_mulv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv4si3 (rtx, rtx, rtx);
extern rtx gen_mulv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_mulv8di3 (rtx, rtx, rtx);
extern rtx gen_mulv4di3 (rtx, rtx, rtx);
extern rtx gen_mulv2di3 (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_hi_v32qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_hi_v32qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_hi_v16qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_hi_v16qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_hi_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_hi_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_hi_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_hi_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_hi_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_hi_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_hi_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_hi_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_lo_v32qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_lo_v32qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_lo_v16qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_lo_v16qi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_lo_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_lo_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_lo_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_lo_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_lo_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_lo_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_lo_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_lo_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_even_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_odd_v16si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_odd_v16si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_odd_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_odd_v8si (rtx, rtx, rtx);
extern rtx gen_vec_widen_smult_odd_v4si (rtx, rtx, rtx);
extern rtx gen_vec_widen_umult_odd_v4si (rtx, rtx, rtx);
extern rtx gen_sdot_prodv32hi (rtx, rtx, rtx, rtx);
extern rtx gen_sdot_prodv16hi (rtx, rtx, rtx, rtx);
extern rtx gen_sdot_prodv8hi (rtx, rtx, rtx, rtx);
extern rtx gen_sdot_prodv4si (rtx, rtx, rtx, rtx);
extern rtx gen_uavgv64qi3_ceil (rtx, rtx, rtx);
extern rtx gen_uavgv32qi3_ceil (rtx, rtx, rtx);
extern rtx gen_uavgv16qi3_ceil (rtx, rtx, rtx);
extern rtx gen_uavgv32hi3_ceil (rtx, rtx, rtx);
extern rtx gen_uavgv16hi3_ceil (rtx, rtx, rtx);
extern rtx gen_uavgv8hi3_ceil (rtx, rtx, rtx);
extern rtx gen_usadv16qi (rtx, rtx, rtx, rtx);
extern rtx gen_usadv32qi (rtx, rtx, rtx, rtx);
extern rtx gen_usadv64qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_shl_v16qi (rtx, rtx, rtx);
extern rtx gen_vec_shl_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_shl_v4si (rtx, rtx, rtx);
extern rtx gen_vec_shl_v2di (rtx, rtx, rtx);
extern rtx gen_vec_shl_v4sf (rtx, rtx, rtx);
extern rtx gen_vec_shl_v2df (rtx, rtx, rtx);
extern rtx gen_vec_shr_v16qi (rtx, rtx, rtx);
extern rtx gen_vec_shr_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_shr_v4si (rtx, rtx, rtx);
extern rtx gen_vec_shr_v2di (rtx, rtx, rtx);
extern rtx gen_vec_shr_v4sf (rtx, rtx, rtx);
extern rtx gen_vec_shr_v2df (rtx, rtx, rtx);
extern rtx gen_smaxv32qi3 (rtx, rtx, rtx);
extern rtx gen_sminv32qi3 (rtx, rtx, rtx);
extern rtx gen_umaxv32qi3 (rtx, rtx, rtx);
extern rtx gen_uminv32qi3 (rtx, rtx, rtx);
extern rtx gen_smaxv16hi3 (rtx, rtx, rtx);
extern rtx gen_sminv16hi3 (rtx, rtx, rtx);
extern rtx gen_umaxv16hi3 (rtx, rtx, rtx);
extern rtx gen_uminv16hi3 (rtx, rtx, rtx);
extern rtx gen_smaxv8si3 (rtx, rtx, rtx);
extern rtx gen_sminv8si3 (rtx, rtx, rtx);
extern rtx gen_umaxv8si3 (rtx, rtx, rtx);
extern rtx gen_uminv8si3 (rtx, rtx, rtx);
extern rtx gen_smaxv64qi3 (rtx, rtx, rtx);
extern rtx gen_sminv64qi3 (rtx, rtx, rtx);
extern rtx gen_umaxv64qi3 (rtx, rtx, rtx);
extern rtx gen_uminv64qi3 (rtx, rtx, rtx);
extern rtx gen_smaxv32hi3 (rtx, rtx, rtx);
extern rtx gen_sminv32hi3 (rtx, rtx, rtx);
extern rtx gen_umaxv32hi3 (rtx, rtx, rtx);
extern rtx gen_uminv32hi3 (rtx, rtx, rtx);
extern rtx gen_smaxv16si3 (rtx, rtx, rtx);
extern rtx gen_sminv16si3 (rtx, rtx, rtx);
extern rtx gen_umaxv16si3 (rtx, rtx, rtx);
extern rtx gen_uminv16si3 (rtx, rtx, rtx);
extern rtx gen_smaxv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sminv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_umaxv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_uminv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_smaxv8di3 (rtx, rtx, rtx);
extern rtx gen_sminv8di3 (rtx, rtx, rtx);
extern rtx gen_umaxv8di3 (rtx, rtx, rtx);
extern rtx gen_uminv8di3 (rtx, rtx, rtx);
extern rtx gen_smaxv4di3 (rtx, rtx, rtx);
extern rtx gen_sminv4di3 (rtx, rtx, rtx);
extern rtx gen_umaxv4di3 (rtx, rtx, rtx);
extern rtx gen_uminv4di3 (rtx, rtx, rtx);
extern rtx gen_smaxv2di3 (rtx, rtx, rtx);
extern rtx gen_sminv2di3 (rtx, rtx, rtx);
extern rtx gen_umaxv2di3 (rtx, rtx, rtx);
extern rtx gen_uminv2di3 (rtx, rtx, rtx);
extern rtx gen_smaxv16qi3 (rtx, rtx, rtx);
extern rtx gen_sminv16qi3 (rtx, rtx, rtx);
extern rtx gen_smaxv8hi3 (rtx, rtx, rtx);
extern rtx gen_sminv8hi3 (rtx, rtx, rtx);
extern rtx gen_smaxv4si3 (rtx, rtx, rtx);
extern rtx gen_sminv4si3 (rtx, rtx, rtx);
extern rtx gen_umaxv16qi3 (rtx, rtx, rtx);
extern rtx gen_uminv16qi3 (rtx, rtx, rtx);
extern rtx gen_umaxv8hi3 (rtx, rtx, rtx);
extern rtx gen_uminv8hi3 (rtx, rtx, rtx);
extern rtx gen_umaxv4si3 (rtx, rtx, rtx);
extern rtx gen_uminv4si3 (rtx, rtx, rtx);
extern rtx gen_avx2_eqv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_eqv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_eqv8si3 (rtx, rtx, rtx);
extern rtx gen_avx2_eqv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv64qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv32qi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_eqv32hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv16hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8hi3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_eqv16si3 (rtx, rtx, rtx);
extern rtx gen_avx512f_eqv16si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv8si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4si3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4si3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_eqv8di3 (rtx, rtx, rtx);
extern rtx gen_avx512f_eqv8di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv4di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv2di3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_eqv2di3_mask (rtx, rtx, rtx, rtx);
extern rtx gen_sse2_eqv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_eqv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_eqv4si3 (rtx, rtx, rtx);
extern rtx gen_sse4_1_eqv2di3 (rtx, rtx, rtx);
extern rtx gen_vcondv64qiv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32hiv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16siv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8div16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16sfv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8dfv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv64qiv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32hiv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16siv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8div8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16sfv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8dfv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv64qiv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32hiv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16siv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8div32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16sfv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8dfv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv64qiv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32hiv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16siv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8div64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16sfv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8dfv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32qiv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16hiv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8siv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4div32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8sfv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4dfv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32qiv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16hiv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8siv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4div16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8sfv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4dfv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32qiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16hiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8siv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4div8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8sfv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4dfv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv32qiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16hiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8siv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4div4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8sfv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4dfv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16qiv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8hiv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4siv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2div16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4sfv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2dfv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16qiv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8hiv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4siv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2div8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4sfv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2dfv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv16qiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv8hiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4siv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2div4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv4sfv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2dfv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2div2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondv2dfv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv64qiv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32hiv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16siv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8div16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16sfv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8dfv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv64qiv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32hiv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16siv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8div8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16sfv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8dfv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv64qiv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32hiv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16siv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8div32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16sfv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8dfv32hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv64qiv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32hiv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16siv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8div64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16sfv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8dfv64qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32qiv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16hiv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8siv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4div32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8sfv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4dfv32qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32qiv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16hiv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8siv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4div16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8sfv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4dfv16hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32qiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16hiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8siv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4div8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8sfv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4dfv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv32qiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16hiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8siv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4div4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8sfv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4dfv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16qiv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8hiv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4siv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2div16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4sfv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2dfv16qi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16qiv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8hiv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4siv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2div8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4sfv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2dfv8hi (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv16qiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv8hiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4siv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2div4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv4sfv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2dfv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2div2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vconduv2dfv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondeqv2div2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcondeqv2dfv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv16qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv8hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv4si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv2di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv4sf (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv2df (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv32qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv16hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv8si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv4di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv8sf (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv4df (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv16sf (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv8df (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv16si (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv8di (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv32hi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_permv64qi (rtx, rtx, rtx, rtx);
extern rtx gen_one_cmplv16si2 (rtx, rtx);
extern rtx gen_one_cmplv8di2 (rtx, rtx);
extern rtx gen_one_cmplv64qi2 (rtx, rtx);
extern rtx gen_one_cmplv32qi2 (rtx, rtx);
extern rtx gen_one_cmplv16qi2 (rtx, rtx);
extern rtx gen_one_cmplv32hi2 (rtx, rtx);
extern rtx gen_one_cmplv16hi2 (rtx, rtx);
extern rtx gen_one_cmplv8hi2 (rtx, rtx);
extern rtx gen_one_cmplv8si2 (rtx, rtx);
extern rtx gen_one_cmplv4si2 (rtx, rtx);
extern rtx gen_one_cmplv4di2 (rtx, rtx);
extern rtx gen_one_cmplv2di2 (rtx, rtx);
extern rtx gen_avx512bw_andnotv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_andnotv32qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_andnotv16qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_andnotv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_andnotv16hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_andnotv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv16si3 (rtx, rtx, rtx);
extern rtx gen_avx2_andnotv8si3 (rtx, rtx, rtx);
extern rtx gen_sse2_andnotv4si3 (rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv8di3 (rtx, rtx, rtx);
extern rtx gen_avx2_andnotv4di3 (rtx, rtx, rtx);
extern rtx gen_sse2_andnotv2di3 (rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_andnotv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_andnotv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_andnotv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_andnotv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_andnotv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_andnotv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_andnotv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_andnotv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_andnotv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_andnotv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_andnotv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_andv16si3 (rtx, rtx, rtx);
extern rtx gen_iorv16si3 (rtx, rtx, rtx);
extern rtx gen_xorv16si3 (rtx, rtx, rtx);
extern rtx gen_andv8di3 (rtx, rtx, rtx);
extern rtx gen_iorv8di3 (rtx, rtx, rtx);
extern rtx gen_xorv8di3 (rtx, rtx, rtx);
extern rtx gen_andv64qi3 (rtx, rtx, rtx);
extern rtx gen_iorv64qi3 (rtx, rtx, rtx);
extern rtx gen_xorv64qi3 (rtx, rtx, rtx);
extern rtx gen_andv32qi3 (rtx, rtx, rtx);
extern rtx gen_iorv32qi3 (rtx, rtx, rtx);
extern rtx gen_xorv32qi3 (rtx, rtx, rtx);
extern rtx gen_andv16qi3 (rtx, rtx, rtx);
extern rtx gen_iorv16qi3 (rtx, rtx, rtx);
extern rtx gen_xorv16qi3 (rtx, rtx, rtx);
extern rtx gen_andv32hi3 (rtx, rtx, rtx);
extern rtx gen_iorv32hi3 (rtx, rtx, rtx);
extern rtx gen_xorv32hi3 (rtx, rtx, rtx);
extern rtx gen_andv16hi3 (rtx, rtx, rtx);
extern rtx gen_iorv16hi3 (rtx, rtx, rtx);
extern rtx gen_xorv16hi3 (rtx, rtx, rtx);
extern rtx gen_andv8hi3 (rtx, rtx, rtx);
extern rtx gen_iorv8hi3 (rtx, rtx, rtx);
extern rtx gen_xorv8hi3 (rtx, rtx, rtx);
extern rtx gen_andv8si3 (rtx, rtx, rtx);
extern rtx gen_iorv8si3 (rtx, rtx, rtx);
extern rtx gen_xorv8si3 (rtx, rtx, rtx);
extern rtx gen_andv4si3 (rtx, rtx, rtx);
extern rtx gen_iorv4si3 (rtx, rtx, rtx);
extern rtx gen_xorv4si3 (rtx, rtx, rtx);
extern rtx gen_andv4di3 (rtx, rtx, rtx);
extern rtx gen_iorv4di3 (rtx, rtx, rtx);
extern rtx gen_xorv4di3 (rtx, rtx, rtx);
extern rtx gen_andv2di3 (rtx, rtx, rtx);
extern rtx gen_iorv2di3 (rtx, rtx, rtx);
extern rtx gen_xorv2di3 (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v32hi (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v16hi (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v8hi (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v16si (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v8si (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v4si (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v8di (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v4di (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_v2di (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_qi (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_hi (rtx, rtx, rtx);
extern rtx gen_vec_pack_trunc_si (rtx, rtx, rtx);
extern rtx gen_vec_pack_sbool_trunc_qi (rtx, rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv32qi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv16hi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv8si (rtx, rtx, rtx);
extern rtx gen_vec_interleave_highv4di (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv32qi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv16hi (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv8si (rtx, rtx, rtx);
extern rtx gen_vec_interleave_lowv4di (rtx, rtx, rtx);
extern rtx gen_avx512dq_vinsertf64x2_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vinserti64x2_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vinsertf32x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vinserti32x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vinsertf32x8_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_vinserti32x8_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vinsertf64x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vinserti64x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_shuf_i64x2_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512dq_shuf_f64x2_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_f64x2_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_i64x2_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_shuf_i32x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_shuf_f32x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_f32x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_shuf_i32x4_mask (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_pshufdv3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_pshufdv3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshufdv3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_pshufd_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshufd (rtx, rtx, rtx);
extern rtx gen_avx512vl_pshuflwv3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pshuflwv3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_pshuflw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshuflw (rtx, rtx, rtx);
extern rtx gen_avx2_pshufhwv3 (rtx, rtx, rtx);
extern rtx gen_avx512vl_pshufhwv3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_pshufhw_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_pshufhw (rtx, rtx, rtx);
extern rtx gen_sse2_loadd (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v64qi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v32qi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v16qi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v32hi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v16hi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v8hi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v16si (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v8si (rtx, rtx);
extern rtx gen_vec_unpacks_lo_v4si (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v64qi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v32qi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v16qi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v32hi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v16hi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v8hi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v16si (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v8si (rtx, rtx);
extern rtx gen_vec_unpacks_hi_v4si (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v64qi (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v32qi (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v16qi (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v32hi (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v16hi (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v8hi (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v16si (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v8si (rtx, rtx);
extern rtx gen_vec_unpacku_lo_v4si (rtx, rtx);
extern rtx gen_vec_unpacks_sbool_lo_qi (rtx, rtx, rtx);
extern rtx gen_vec_unpacks_lo_hi (rtx, rtx);
extern rtx gen_vec_unpacks_lo_si (rtx, rtx);
extern rtx gen_vec_unpacks_lo_di (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v64qi (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v32qi (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v16qi (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v32hi (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v16hi (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v8hi (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v16si (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v8si (rtx, rtx);
extern rtx gen_vec_unpacku_hi_v4si (rtx, rtx);
extern rtx gen_vec_unpacks_sbool_hi_qi (rtx, rtx, rtx);
extern rtx gen_vec_unpacks_hi_hi (rtx, rtx);
extern rtx gen_vec_unpacks_hi_si (rtx, rtx);
extern rtx gen_vec_unpacks_hi_di (rtx, rtx);
extern rtx gen_avx512bw_uavgv64qi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_uavgv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_uavgv32qi3 (rtx, rtx, rtx);
extern rtx gen_avx2_uavgv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_uavgv16qi3 (rtx, rtx, rtx);
extern rtx gen_sse2_uavgv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_uavgv32hi3 (rtx, rtx, rtx);
extern rtx gen_avx512bw_uavgv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_uavgv16hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_uavgv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_uavgv8hi3 (rtx, rtx, rtx);
extern rtx gen_sse2_uavgv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_maskmovdqu (rtx, rtx, rtx);
extern rtx gen_ssse3_pmulhrswv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_pmulhrswv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_ssse3_pmulhrswv8hi3 (rtx, rtx, rtx);
extern rtx gen_avx2_pmulhrswv16hi3 (rtx, rtx, rtx);
extern rtx gen_smulhrsv32hi3 (rtx, rtx, rtx);
extern rtx gen_smulhrsv16hi3 (rtx, rtx, rtx);
extern rtx gen_smulhrsv8hi3 (rtx, rtx, rtx);
extern rtx gen_smulhrsv4hi3 (rtx, rtx, rtx);
extern rtx gen_ssse3_pmulhrswv4hi3 (rtx, rtx, rtx);
extern rtx gen_absv64qi2 (rtx, rtx);
extern rtx gen_absv32qi2 (rtx, rtx);
extern rtx gen_absv16qi2 (rtx, rtx);
extern rtx gen_absv32hi2 (rtx, rtx);
extern rtx gen_absv16hi2 (rtx, rtx);
extern rtx gen_absv8hi2 (rtx, rtx);
extern rtx gen_absv16si2 (rtx, rtx);
extern rtx gen_absv8si2 (rtx, rtx);
extern rtx gen_absv4si2 (rtx, rtx);
extern rtx gen_absv8di2 (rtx, rtx);
extern rtx gen_absv4di2 (rtx, rtx);
extern rtx gen_absv2di2 (rtx, rtx);
extern rtx gen_avx2_pblendw (rtx, rtx, rtx, rtx);
extern rtx gen_sign_extendv16qiv16hi2 (rtx, rtx);
extern rtx gen_zero_extendv16qiv16hi2 (rtx, rtx);
extern rtx gen_sign_extendv32qiv32hi2 (rtx, rtx);
extern rtx gen_zero_extendv32qiv32hi2 (rtx, rtx);
extern rtx gen_sign_extendv8qiv8hi2 (rtx, rtx);
extern rtx gen_zero_extendv8qiv8hi2 (rtx, rtx);
extern rtx gen_sign_extendv16qiv16si2 (rtx, rtx);
extern rtx gen_zero_extendv16qiv16si2 (rtx, rtx);
extern rtx gen_sign_extendv8qiv8si2 (rtx, rtx);
extern rtx gen_zero_extendv8qiv8si2 (rtx, rtx);
extern rtx gen_sign_extendv4qiv4si2 (rtx, rtx);
extern rtx gen_zero_extendv4qiv4si2 (rtx, rtx);
extern rtx gen_sign_extendv16hiv16si2 (rtx, rtx);
extern rtx gen_zero_extendv16hiv16si2 (rtx, rtx);
extern rtx gen_sign_extendv8hiv8si2 (rtx, rtx);
extern rtx gen_zero_extendv8hiv8si2 (rtx, rtx);
extern rtx gen_sign_extendv4hiv4si2 (rtx, rtx);
extern rtx gen_zero_extendv4hiv4si2 (rtx, rtx);
extern rtx gen_sign_extendv8qiv8di2 (rtx, rtx);
extern rtx gen_zero_extendv8qiv8di2 (rtx, rtx);
extern rtx gen_sign_extendv4qiv4di2 (rtx, rtx);
extern rtx gen_zero_extendv4qiv4di2 (rtx, rtx);
extern rtx gen_sign_extendv2qiv2di2 (rtx, rtx);
extern rtx gen_zero_extendv2qiv2di2 (rtx, rtx);
extern rtx gen_sign_extendv8hiv8di2 (rtx, rtx);
extern rtx gen_zero_extendv8hiv8di2 (rtx, rtx);
extern rtx gen_sign_extendv4hiv4di2 (rtx, rtx);
extern rtx gen_zero_extendv4hiv4di2 (rtx, rtx);
extern rtx gen_sign_extendv2hiv2di2 (rtx, rtx);
extern rtx gen_zero_extendv2hiv2di2 (rtx, rtx);
extern rtx gen_sign_extendv8siv8di2 (rtx, rtx);
extern rtx gen_zero_extendv8siv8di2 (rtx, rtx);
extern rtx gen_sign_extendv4siv4di2 (rtx, rtx);
extern rtx gen_zero_extendv4siv4di2 (rtx, rtx);
extern rtx gen_sign_extendv2siv2di2 (rtx, rtx);
extern rtx gen_zero_extendv2siv2di2 (rtx, rtx);
extern rtx gen_nearbyintv16sf2 (rtx, rtx);
extern rtx gen_nearbyintv8sf2 (rtx, rtx);
extern rtx gen_nearbyintv4sf2 (rtx, rtx);
extern rtx gen_nearbyintv8df2 (rtx, rtx);
extern rtx gen_nearbyintv4df2 (rtx, rtx);
extern rtx gen_nearbyintv2df2 (rtx, rtx);
extern rtx gen_rintv16sf2 (rtx, rtx);
extern rtx gen_rintv8sf2 (rtx, rtx);
extern rtx gen_rintv4sf2 (rtx, rtx);
extern rtx gen_rintv8df2 (rtx, rtx);
extern rtx gen_rintv4df2 (rtx, rtx);
extern rtx gen_rintv2df2 (rtx, rtx);
extern rtx gen_avx_roundps_sfix256 (rtx, rtx, rtx);
extern rtx gen_sse4_1_roundps_sfix (rtx, rtx, rtx);
extern rtx gen_avx512f_roundps512 (rtx, rtx, rtx);
extern rtx gen_avx512f_roundpd512 (rtx, rtx, rtx);
extern rtx gen_avx512f_roundps512_sfix (rtx, rtx, rtx);
extern rtx gen_avx512f_roundpd_vec_pack_sfix512 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_roundpd_vec_pack_sfix256 (rtx, rtx, rtx, rtx);
extern rtx gen_sse4_1_roundpd_vec_pack_sfix (rtx, rtx, rtx, rtx);
extern rtx gen_roundv16sf2 (rtx, rtx);
extern rtx gen_roundv8sf2 (rtx, rtx);
extern rtx gen_roundv4sf2 (rtx, rtx);
extern rtx gen_roundv8df2 (rtx, rtx);
extern rtx gen_roundv4df2 (rtx, rtx);
extern rtx gen_roundv2df2 (rtx, rtx);
extern rtx gen_roundv16sf2_sfix (rtx, rtx);
extern rtx gen_roundv8sf2_sfix (rtx, rtx);
extern rtx gen_roundv4sf2_sfix (rtx, rtx);
extern rtx gen_roundv8df2_vec_pack_sfix (rtx, rtx, rtx);
extern rtx gen_roundv4df2_vec_pack_sfix (rtx, rtx, rtx);
extern rtx gen_roundv2df2_vec_pack_sfix (rtx, rtx, rtx);
extern rtx gen_avx512pf_gatherpfv16sisf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_gatherpfv8disf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_gatherpfv8sidf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_gatherpfv8didf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_scatterpfv16sisf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_scatterpfv8disf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_scatterpfv8sidf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512pf_scatterpfv8didf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_rotlv16qi3 (rtx, rtx, rtx);
extern rtx gen_rotlv8hi3 (rtx, rtx, rtx);
extern rtx gen_rotlv4si3 (rtx, rtx, rtx);
extern rtx gen_rotlv2di3 (rtx, rtx, rtx);
extern rtx gen_rotrv16qi3 (rtx, rtx, rtx);
extern rtx gen_rotrv8hi3 (rtx, rtx, rtx);
extern rtx gen_rotrv4si3 (rtx, rtx, rtx);
extern rtx gen_rotrv2di3 (rtx, rtx, rtx);
extern rtx gen_vrotrv16qi3 (rtx, rtx, rtx);
extern rtx gen_vrotrv8hi3 (rtx, rtx, rtx);
extern rtx gen_vrotrv4si3 (rtx, rtx, rtx);
extern rtx gen_vrotrv2di3 (rtx, rtx, rtx);
extern rtx gen_vrotlv16qi3 (rtx, rtx, rtx);
extern rtx gen_vrotlv8hi3 (rtx, rtx, rtx);
extern rtx gen_vrotlv4si3 (rtx, rtx, rtx);
extern rtx gen_vrotlv2di3 (rtx, rtx, rtx);
extern rtx gen_vlshrv16qi3 (rtx, rtx, rtx);
extern rtx gen_vlshrv8hi3 (rtx, rtx, rtx);
extern rtx gen_vlshrv4si3 (rtx, rtx, rtx);
extern rtx gen_vlshrv2di3 (rtx, rtx, rtx);
extern rtx gen_vlshrv16si3 (rtx, rtx, rtx);
extern rtx gen_vlshrv8di3 (rtx, rtx, rtx);
extern rtx gen_vlshrv8si3 (rtx, rtx, rtx);
extern rtx gen_vlshrv4di3 (rtx, rtx, rtx);
extern rtx gen_vashrv8hi3 (rtx, rtx, rtx);
extern rtx gen_vashrv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vashrv16qi3 (rtx, rtx, rtx);
extern rtx gen_vashrv2di3 (rtx, rtx, rtx);
extern rtx gen_vashrv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vashrv4si3 (rtx, rtx, rtx);
extern rtx gen_vashrv16si3 (rtx, rtx, rtx);
extern rtx gen_vashrv8si3 (rtx, rtx, rtx);
extern rtx gen_vashlv16qi3 (rtx, rtx, rtx);
extern rtx gen_vashlv8hi3 (rtx, rtx, rtx);
extern rtx gen_vashlv4si3 (rtx, rtx, rtx);
extern rtx gen_vashlv2di3 (rtx, rtx, rtx);
extern rtx gen_vashlv16si3 (rtx, rtx, rtx);
extern rtx gen_vashlv8di3 (rtx, rtx, rtx);
extern rtx gen_vashlv8si3 (rtx, rtx, rtx);
extern rtx gen_vashlv4di3 (rtx, rtx, rtx);
extern rtx gen_ashlv64qi3 (rtx, rtx, rtx);
extern rtx gen_lshrv64qi3 (rtx, rtx, rtx);
extern rtx gen_ashrv64qi3 (rtx, rtx, rtx);
extern rtx gen_ashlv32qi3 (rtx, rtx, rtx);
extern rtx gen_lshrv32qi3 (rtx, rtx, rtx);
extern rtx gen_ashrv32qi3 (rtx, rtx, rtx);
extern rtx gen_ashlv16qi3 (rtx, rtx, rtx);
extern rtx gen_lshrv16qi3 (rtx, rtx, rtx);
extern rtx gen_ashrv16qi3 (rtx, rtx, rtx);
extern rtx gen_ashrv2di3 (rtx, rtx, rtx);
extern rtx gen_xop_vmfrczv4sf2 (rtx, rtx);
extern rtx gen_xop_vmfrczv2df2 (rtx, rtx);
extern rtx gen_avx_vzeroall (void);
extern rtx gen_avx_vzeroupper (void);
extern rtx gen_avx512f_vpermilv8df (rtx, rtx, rtx);
extern rtx gen_avx512f_vpermilv8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilv4df (rtx, rtx, rtx);
extern rtx gen_avx_vpermilv4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilv2df (rtx, rtx, rtx);
extern rtx gen_avx_vpermilv2df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermilv16sf (rtx, rtx, rtx);
extern rtx gen_avx512f_vpermilv16sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilv8sf (rtx, rtx, rtx);
extern rtx gen_avx_vpermilv8sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vpermilv4sf (rtx, rtx, rtx);
extern rtx gen_avx_vpermilv4sf_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_permv4di (rtx, rtx, rtx);
extern rtx gen_avx2_permv4df (rtx, rtx, rtx);
extern rtx gen_avx512vl_permv4di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_permv4df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permv8df (rtx, rtx, rtx);
extern rtx gen_avx512f_permv8di (rtx, rtx, rtx);
extern rtx gen_avx512f_permv8df_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_permv8di_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermi2varv16si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermi2varv16sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermi2varv8di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermi2varv8df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv8si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv8sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv4di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv4df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv4si3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv4sf3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv2di3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv2df3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermi2varv32hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv16hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv8hi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermi2varv64qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv32qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermi2varv16qi3_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16si3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv16sf3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8di3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_vpermt2varv8df3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8si3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8sf3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4di3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4df3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4si3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv4sf3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2di3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv2df3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv32hi3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16hi3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv8hi3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512bw_vpermt2varv64qi3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv32qi3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vpermt2varv16qi3_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vperm2f128v8si3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vperm2f128v8sf3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vperm2f128v4df3 (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vinsertv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vinsertv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vinsertv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_vinsertv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx_vinsertf128v32qi (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vinsertf128v16hi (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vinsertf128v8si (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vinsertf128v4di (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vinsertf128v8sf (rtx, rtx, rtx, rtx);
extern rtx gen_avx_vinsertf128v4df (rtx, rtx, rtx, rtx);
extern rtx gen_maskloadv4sfv4si (rtx, rtx, rtx);
extern rtx gen_maskloadv2dfv2di (rtx, rtx, rtx);
extern rtx gen_maskloadv8sfv8si (rtx, rtx, rtx);
extern rtx gen_maskloadv4dfv4di (rtx, rtx, rtx);
extern rtx gen_maskloadv4siv4si (rtx, rtx, rtx);
extern rtx gen_maskloadv2div2di (rtx, rtx, rtx);
extern rtx gen_maskloadv8siv8si (rtx, rtx, rtx);
extern rtx gen_maskloadv4div4di (rtx, rtx, rtx);
extern rtx gen_maskloadv16sihi (rtx, rtx, rtx);
extern rtx gen_maskloadv8siqi (rtx, rtx, rtx);
extern rtx gen_maskloadv4siqi (rtx, rtx, rtx);
extern rtx gen_maskloadv8diqi (rtx, rtx, rtx);
extern rtx gen_maskloadv4diqi (rtx, rtx, rtx);
extern rtx gen_maskloadv2diqi (rtx, rtx, rtx);
extern rtx gen_maskloadv16sfhi (rtx, rtx, rtx);
extern rtx gen_maskloadv8sfqi (rtx, rtx, rtx);
extern rtx gen_maskloadv4sfqi (rtx, rtx, rtx);
extern rtx gen_maskloadv8dfqi (rtx, rtx, rtx);
extern rtx gen_maskloadv4dfqi (rtx, rtx, rtx);
extern rtx gen_maskloadv2dfqi (rtx, rtx, rtx);
extern rtx gen_maskloadv64qidi (rtx, rtx, rtx);
extern rtx gen_maskloadv16qihi (rtx, rtx, rtx);
extern rtx gen_maskloadv32qisi (rtx, rtx, rtx);
extern rtx gen_maskloadv32hisi (rtx, rtx, rtx);
extern rtx gen_maskloadv16hihi (rtx, rtx, rtx);
extern rtx gen_maskloadv8hiqi (rtx, rtx, rtx);
extern rtx gen_maskstorev4sfv4si (rtx, rtx, rtx);
extern rtx gen_maskstorev2dfv2di (rtx, rtx, rtx);
extern rtx gen_maskstorev8sfv8si (rtx, rtx, rtx);
extern rtx gen_maskstorev4dfv4di (rtx, rtx, rtx);
extern rtx gen_maskstorev4siv4si (rtx, rtx, rtx);
extern rtx gen_maskstorev2div2di (rtx, rtx, rtx);
extern rtx gen_maskstorev8siv8si (rtx, rtx, rtx);
extern rtx gen_maskstorev4div4di (rtx, rtx, rtx);
extern rtx gen_maskstorev16sihi (rtx, rtx, rtx);
extern rtx gen_maskstorev8siqi (rtx, rtx, rtx);
extern rtx gen_maskstorev4siqi (rtx, rtx, rtx);
extern rtx gen_maskstorev8diqi (rtx, rtx, rtx);
extern rtx gen_maskstorev4diqi (rtx, rtx, rtx);
extern rtx gen_maskstorev2diqi (rtx, rtx, rtx);
extern rtx gen_maskstorev16sfhi (rtx, rtx, rtx);
extern rtx gen_maskstorev8sfqi (rtx, rtx, rtx);
extern rtx gen_maskstorev4sfqi (rtx, rtx, rtx);
extern rtx gen_maskstorev8dfqi (rtx, rtx, rtx);
extern rtx gen_maskstorev4dfqi (rtx, rtx, rtx);
extern rtx gen_maskstorev2dfqi (rtx, rtx, rtx);
extern rtx gen_maskstorev64qidi (rtx, rtx, rtx);
extern rtx gen_maskstorev16qihi (rtx, rtx, rtx);
extern rtx gen_maskstorev32qisi (rtx, rtx, rtx);
extern rtx gen_maskstorev32hisi (rtx, rtx, rtx);
extern rtx gen_maskstorev16hihi (rtx, rtx, rtx);
extern rtx gen_maskstorev8hiqi (rtx, rtx, rtx);
extern rtx gen_cbranchv4si4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchv2di4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchv8si4 (rtx, rtx, rtx, rtx);
extern rtx gen_cbranchv4di4 (rtx, rtx, rtx, rtx);
extern rtx gen_vec_initv64qiqi (rtx, rtx);
extern rtx gen_vec_initv32qiqi (rtx, rtx);
extern rtx gen_vec_initv16qiqi (rtx, rtx);
extern rtx gen_vec_initv32hihi (rtx, rtx);
extern rtx gen_vec_initv16hihi (rtx, rtx);
extern rtx gen_vec_initv8hihi (rtx, rtx);
extern rtx gen_vec_initv16sisi (rtx, rtx);
extern rtx gen_vec_initv8sisi (rtx, rtx);
extern rtx gen_vec_initv4sisi (rtx, rtx);
extern rtx gen_vec_initv8didi (rtx, rtx);
extern rtx gen_vec_initv4didi (rtx, rtx);
extern rtx gen_vec_initv2didi (rtx, rtx);
extern rtx gen_vec_initv16sfsf (rtx, rtx);
extern rtx gen_vec_initv8sfsf (rtx, rtx);
extern rtx gen_vec_initv4sfsf (rtx, rtx);
extern rtx gen_vec_initv8dfdf (rtx, rtx);
extern rtx gen_vec_initv4dfdf (rtx, rtx);
extern rtx gen_vec_initv2dfdf (rtx, rtx);
extern rtx gen_vec_initv4titi (rtx, rtx);
extern rtx gen_vec_initv2titi (rtx, rtx);
extern rtx gen_vec_initv64qiv32qi (rtx, rtx);
extern rtx gen_vec_initv32qiv16qi (rtx, rtx);
extern rtx gen_vec_initv16qiv8qi (rtx, rtx);
extern rtx gen_vec_initv32hiv16hi (rtx, rtx);
extern rtx gen_vec_initv16hiv8hi (rtx, rtx);
extern rtx gen_vec_initv8hiv4hi (rtx, rtx);
extern rtx gen_vec_initv16siv8si (rtx, rtx);
extern rtx gen_vec_initv8siv4si (rtx, rtx);
extern rtx gen_vec_initv4siv2si (rtx, rtx);
extern rtx gen_vec_initv8div4di (rtx, rtx);
extern rtx gen_vec_initv4div2di (rtx, rtx);
extern rtx gen_vec_initv16sfv8sf (rtx, rtx);
extern rtx gen_vec_initv8sfv4sf (rtx, rtx);
extern rtx gen_vec_initv4sfv2sf (rtx, rtx);
extern rtx gen_vec_initv8dfv4df (rtx, rtx);
extern rtx gen_vec_initv4dfv2df (rtx, rtx);
extern rtx gen_vec_initv4tiv2ti (rtx, rtx);
extern rtx gen_vcvtps2ph_mask (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vcvtps2ph (rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gathersiv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx2_gatherdiv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gathersiv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gathersiv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gathersiv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gathersiv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gathersiv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gatherdiv16si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gatherdiv16sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gatherdiv8di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_gatherdiv8df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv8si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv8sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv4di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv4df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv4si (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv4sf (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv2di (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_gatherdiv2df (rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scattersiv16si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scattersiv16sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scattersiv8di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scattersiv8df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv8si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv8sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv4di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv4df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv4si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv4sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv2di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scattersiv2df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scatterdiv16si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scatterdiv16sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scatterdiv8di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_scatterdiv8df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv8si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv8sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv4di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv4df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv4si (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv4sf (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv2di (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_scatterdiv2df (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv16si_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv16sf_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv8di_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_expandv8df_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv8si_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv8sf_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4di_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4df_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4si_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv4sf_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv2di_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512vl_expandv2df_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_expandv64qi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_expandv16qi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_expandv32qi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_expandv32hi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_expandv16hi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_expandv8hi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv8di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv4di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52huqv2di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv8di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv4di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpamdd52luqv2di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_movv64sf (rtx, rtx);
extern rtx gen_movv64si (rtx, rtx);
extern rtx gen_vpshrdv_v32hi_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v16hi_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v8hi_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v4si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshrdv_v2di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v32hi_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v16hi_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v8hi_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v4si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpshldv_v2di_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v16si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v8si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusd_v4si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v16si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v8si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpbusds_v4si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v16si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v8si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssd_v4si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v16si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v8si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_vpdpwssds_v4si_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v32hi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v16hi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtne2ps2bf16_v8hi_maskz (rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v16sf_maskz (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v8sf_maskz (rtx, rtx, rtx);
extern rtx gen_avx512f_cvtneps2bf16_v4sf_maskz (rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v16sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v8sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_avx512f_dpbf16ps_v4sf_maskz (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_sse2_lfence (void);
extern rtx gen_sse_sfence (void);
extern rtx gen_sse2_mfence (void);
extern rtx gen_mem_thread_fence (rtx);
extern rtx gen_atomic_loadqi (rtx, rtx, rtx);
extern rtx gen_atomic_loadhi (rtx, rtx, rtx);
extern rtx gen_atomic_loadsi (rtx, rtx, rtx);
extern rtx gen_atomic_loaddi (rtx, rtx, rtx);
extern rtx gen_atomic_storeqi (rtx, rtx, rtx);
extern rtx gen_atomic_storehi (rtx, rtx, rtx);
extern rtx gen_atomic_storesi (rtx, rtx, rtx);
extern rtx gen_atomic_storedi (rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapqi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swaphi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapsi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapdi (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_compare_and_swapti (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_sethi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_setsi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_setdi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_complementhi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_complementsi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_complementdi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_resethi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_resetsi (rtx, rtx, rtx, rtx, rtx);
extern rtx gen_atomic_bit_test_and_resetdi (rtx, rtx, rtx, rtx, rtx);
# 44 "./tm.h" 2
# 1 "./insn-modes.h" 1
# 47 "./tm.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/defaults.h" 1
# 1473 "/home/giulianob/gcc_git_gnu/gcc/gcc/defaults.h"
typedef uint8_t target_unit;
# 49 "./tm.h" 2
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
struct sequence_stack {
rtx_insn *first;
rtx_insn *last;
struct sequence_stack *next;
};
struct emit_status {
void ensure_regno_capacity ();
int x_reg_rtx_no;
int x_first_label_num;
# 56 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
struct sequence_stack seq;
int x_cur_insn_uid;
int x_cur_debug_insn_uid;
int regno_pointer_align_length;
unsigned char * regno_pointer_align;
};
# 87 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
extern rtx * regno_reg_rtx;
struct expr_status {
poly_int64_pod x_pending_stack_adjust;
# 114 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
int x_inhibit_defer_pop;
poly_int64_pod x_stack_pointer_delta;
rtx x_saveregs_value;
rtx x_apply_args_value;
vec<rtx_insn *, va_gc> *x_forced_labels;
};
typedef struct call_site_record_d *call_site_record;
struct rtl_eh {
rtx ehr_stackadj;
rtx ehr_handler;
rtx_code_label *ehr_label;
rtx sjlj_fc;
rtx_insn *sjlj_exit_after;
vec<uchar, va_gc> *action_record_data;
vec<call_site_record, va_gc> *call_site_record_v[2];
};
# 157 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
struct gimple_df;
struct call_site_record_d;
struct dw_fde_node;
struct varasm_status {
struct rtx_constant_pool *pool;
unsigned int deferred_constants;
};
struct function_subsections {
const char *hot_section_label;
const char *cold_section_label;
const char *hot_section_end_label;
const char *cold_section_end_label;
};
class frame_space
{
public:
class frame_space *next;
poly_int64 start;
poly_int64 length;
};
struct callinfo_callee
{
location_t location;
tree decl;
};
struct callinfo_dalloc
{
location_t location;
char const *name;
};
class stack_usage
{
public:
long static_stack_size;
long dynamic_stack_size;
poly_int64 pushed_stack_size;
unsigned int has_unbounded_dynamic_stack_size : 1;
vec<callinfo_callee, va_gc> *callees;
vec<callinfo_dalloc, va_gc> *dallocs;
};
# 248 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
struct function {
struct eh_status *eh;
struct control_flow_graph *cfg;
gimple_seq gimple_body;
struct gimple_df *gimple_df;
struct loops *x_current_loops;
char *pass_startwith;
class stack_usage *su;
htab_t value_histograms;
tree decl;
tree static_chain_decl;
tree nonlocal_goto_save_area;
vec<tree, va_gc> *local_decls;
struct machine_function * machine;
struct language_function * language;
hash_set<tree> * used_types_hash;
struct dw_fde_node *fde;
int last_stmt_uid;
int debug_marker_count;
int funcdef_no;
location_t function_start_locus;
location_t function_end_locus;
unsigned int curr_properties;
unsigned int last_verified;
const char * cannot_be_copied_reason;
unsigned short last_clique;
unsigned int va_list_gpr_size : 8;
unsigned int va_list_fpr_size : 8;
unsigned int calls_setjmp : 1;
unsigned int calls_alloca : 1;
unsigned int calls_eh_return : 1;
unsigned int has_nonlocal_label : 1;
unsigned int has_forced_label_in_static : 1;
unsigned int cannot_be_copied_set : 1;
unsigned int stdarg : 1;
unsigned int after_inlining : 1;
unsigned int always_inline_functions_inlined : 1;
unsigned int can_throw_non_call_exceptions : 1;
unsigned int can_delete_dead_exceptions : 1;
unsigned int returns_struct : 1;
unsigned int returns_pcc_struct : 1;
unsigned int has_local_explicit_reg_vars : 1;
unsigned int is_thunk : 1;
unsigned int has_force_vectorize_loops : 1;
unsigned int has_simduid_loops : 1;
unsigned int tail_call_marked : 1;
unsigned int has_unroll : 1;
unsigned int debug_nonbind_markers : 1;
unsigned int coroutine_component : 1;
unsigned int has_omp_target : 1;
};
void add_local_decl (struct function *fun, tree d);
void record_final_call (tree callee, location_t location);
void record_dynamic_alloc (tree decl_or_exp);
extern struct function *cfun;
extern int virtuals_instantiated;
extern int trampolines_created;
struct types_used_by_vars_entry {
tree type;
tree var_decl;
};
struct used_type_hasher : ggc_ptr_hash<types_used_by_vars_entry>
{
static hashval_t hash (types_used_by_vars_entry *);
static bool equal (types_used_by_vars_entry *, types_used_by_vars_entry *);
};
extern hash_table<used_type_hasher> *types_used_by_vars_hash;
void types_used_by_var_decl_insert (tree type, tree var_decl);
extern vec<tree, va_gc> *types_used_by_cur_var_decl;
inline struct loops *
loops_for_fn (struct function *fn)
{
return fn->x_current_loops;
}
inline void
set_loops_for_fn (struct function *fn, struct loops *loops)
{
((void)(!(fn->x_current_loops == nullptr || loops == nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/function.h", 499, __FUNCTION__), 0 : 0));
fn->x_current_loops = loops;
}
# 513 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
extern struct machine_function * (*init_machine_status) (void);
struct args_size
{
poly_int64_pod constant;
tree var;
};
struct locate_and_pad_arg_data
{
struct args_size size;
struct args_size offset;
struct args_size slot_offset;
struct args_size alignment_pad;
pad_direction where_pad;
unsigned int boundary;
};
# 597 "/home/giulianob/gcc_git_gnu/gcc/gcc/function.h"
enum stack_clash_probes {
NO_PROBE_NO_FRAME,
NO_PROBE_SMALL_FRAME,
PROBE_INLINE,
PROBE_LOOP
};
extern void dump_stack_clash_frame_info (enum stack_clash_probes, bool);
extern void push_function_context (void);
extern void pop_function_context (void);
extern void free_after_parsing (struct function *);
extern void free_after_compilation (struct function *);
extern poly_int64 get_frame_size (void);
extern bool frame_offset_overflow (poly_int64, tree);
extern unsigned int spill_slot_alignment (machine_mode);
extern rtx assign_stack_local_1 (machine_mode, poly_int64, int, int);
extern rtx assign_stack_local (machine_mode, poly_int64, int);
extern rtx assign_stack_temp_for_type (machine_mode, poly_int64, tree);
extern rtx assign_stack_temp (machine_mode, poly_int64);
extern rtx assign_temp (tree, int, int);
extern void update_temp_slot_address (rtx, rtx);
extern void preserve_temp_slots (rtx);
extern void free_temp_slots (void);
extern void push_temp_slots (void);
extern void pop_temp_slots (void);
extern void init_temp_slots (void);
extern rtx get_hard_reg_initial_reg (rtx);
extern rtx get_hard_reg_initial_val (machine_mode, unsigned int);
extern rtx has_hard_reg_initial_val (machine_mode, unsigned int);
extern unsigned int emit_initial_value_sets (void);
extern bool initial_value_entry (int i, rtx *, rtx *);
extern void instantiate_decl_rtl (rtx x);
extern int aggregate_value_p (const_tree, const_tree);
extern bool use_register_for_decl (const_tree);
extern gimple_seq gimplify_parameters (gimple_seq *);
extern void locate_and_pad_parm (machine_mode, tree, int, int, int,
tree, struct args_size *,
struct locate_and_pad_arg_data *);
extern void generate_setjmp_warnings (void);
extern void reorder_blocks (void);
extern void clear_block_marks (tree);
extern tree blocks_nreverse (tree);
extern tree block_chainon (tree, tree);
extern void number_blocks (tree);
extern void set_cfun (struct function *new_cfun, bool force = false);
extern void push_cfun (struct function *new_cfun);
extern void pop_cfun (void);
extern int get_next_funcdef_no (void);
extern int get_last_funcdef_no (void);
extern void allocate_struct_function (tree, bool);
extern void push_struct_function (tree fndecl);
extern void push_dummy_function (bool);
extern void pop_dummy_function (void);
extern void init_dummy_function_start (void);
extern void init_function_start (tree);
extern void stack_protect_epilogue (void);
extern void expand_function_start (tree);
extern void expand_dummy_function_end (void);
extern void thread_prologue_and_epilogue_insns (void);
extern void diddle_return_value (void (*)(rtx, void*), void*);
extern void clobber_return_register (void);
extern void expand_function_end (void);
extern rtx get_arg_pointer_save_area (void);
extern void maybe_copy_prologue_epilogue_insn (rtx, rtx);
extern int prologue_contains (const rtx_insn *);
extern int epilogue_contains (const rtx_insn *);
extern int prologue_epilogue_contains (const rtx_insn *);
extern void record_prologue_seq (rtx_insn *);
extern void record_epilogue_seq (rtx_insn *);
extern void emit_return_into_block (bool simple_p, basic_block bb);
extern void set_return_jump_label (rtx_insn *);
extern bool active_insn_between (rtx_insn *head, rtx_insn *tail);
extern vec<edge> convert_jumps_to_returns (basic_block last_bb, bool simple_p,
vec<edge> unconverted);
extern basic_block emit_return_for_exit (edge exit_fallthru_edge,
bool simple_p);
extern void reposition_prologue_and_epilogue_notes (void);
extern const char *fndecl_name (tree);
extern const char *function_name (struct function *);
extern const char *current_function_name (void);
extern void used_types_insert (tree);
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 1
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h" 1
# 111 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4
# 112 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h" 2
# 153 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
extern "C" {
struct _obstack_chunk
{
char *limit;
struct _obstack_chunk *prev;
char contents[4];
};
struct obstack
{
size_t chunk_size;
struct _obstack_chunk *chunk;
char *object_base;
char *next_free;
char *chunk_limit;
union
{
size_t i;
void *p;
} temp;
size_t alignment_mask;
union
{
void *(*plain) (size_t);
void *(*extra) (void *, size_t);
} chunkfun;
union
{
void (*plain) (void *);
void (*extra) (void *, void *);
} freefun;
void *extra_arg;
unsigned use_extra_arg : 1;
unsigned maybe_empty_object : 1;
unsigned alloc_failed : 1;
};
extern void _obstack_newchunk (struct obstack *, size_t);
extern void _obstack_free (struct obstack *, void *);
extern int _obstack_begin (struct obstack *,
size_t, size_t,
void *(*) (size_t), void (*) (void *));
extern int _obstack_begin_1 (struct obstack *,
size_t, size_t,
void *(*) (void *, size_t),
void (*) (void *, void *), void *);
extern size_t _obstack_memory_used (struct obstack *)
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h" 3 4
__attribute__ ((__pure__))
# 212 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
;
extern void (*obstack_alloc_failed_handler) (void);
extern int obstack_exit_failure;
# 532 "/home/giulianob/gcc_git_gnu/gcc/gcc/../include/obstack.h"
}
# 213 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/array-traits.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/array-traits.h"
template<typename T, T zero = T (0)>
struct scalar_array_traits
{
typedef T element_type;
static const bool has_constant_size = true;
static const size_t constant_size = 1;
static const T *base (const T &x) { return &x; }
static size_t size (const T &) { return 1; }
};
template<typename T>
struct array_traits : scalar_array_traits<T> {};
template<typename T, size_t N>
struct array_traits<T[N]>
{
typedef T element_type;
static const bool has_constant_size = true;
static const size_t constant_size = N;
static const T *base (const T (&x)[N]) { return x; }
static size_t size (const T (&)[N]) { return N; }
};
# 214 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 2
class bitmap_usage: public mem_usage
{
public:
bitmap_usage (): m_nsearches (0), m_search_iter (0) {}
bitmap_usage (size_t allocated, size_t times, size_t peak,
uint64_t nsearches, uint64_t search_iter)
: mem_usage (allocated, times, peak),
m_nsearches (nsearches), m_search_iter (search_iter) {}
bitmap_usage
operator+ (const bitmap_usage &second)
{
return bitmap_usage (m_allocated + second.m_allocated,
m_times + second.m_times,
m_peak + second.m_peak,
m_nsearches + second.m_nsearches,
m_search_iter + second.m_search_iter);
}
inline void
dump (mem_location *loc, const mem_usage &total) const
{
char *location_string = loc->to_string ();
fprintf (
# 244 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
stderr
# 244 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
, "%-48s " "%" "9"
# 244 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
"l" "u"
# 244 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
"%c" ":%5.1f%%"
"%" "9"
# 245 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
"l" "u"
# 245 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
"%c" "%" "9"
# 245 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
"l" "u"
# 245 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
"%c" ":%5.1f%%"
"%" "11"
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
"l" "u"
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
"%c" "%" "11"
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
"l" "u"
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
"%c" "%10s\n",
location_string, (uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_allocated, total.m_allocated),
(uint64_t)(((m_peak) < 10 * 1024 ? (m_peak) : ((m_peak) < 10 * (1024 * 1024) ? (m_peak) / 1024 : (m_peak) / (1024 * 1024)))), ((m_peak) < 10 * 1024 ? ' ' : ((m_peak) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_times) < 10 * 1024 ? (m_times) : ((m_times) < 10 * (1024 * 1024) ? (m_times) / 1024 : (m_times) / (1024 * 1024)))), ((m_times) < 10 * 1024 ? ' ' : ((m_times) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_times, total.m_times),
(uint64_t)(((m_nsearches) < 10 * 1024 ? (m_nsearches) : ((m_nsearches) < 10 * (1024 * 1024) ? (m_nsearches) / 1024 : (m_nsearches) / (1024 * 1024)))), ((m_nsearches) < 10 * 1024 ? ' ' : ((m_nsearches) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_search_iter) < 10 * 1024 ? (m_search_iter) : ((m_search_iter) < 10 * (1024 * 1024) ? (m_search_iter) / 1024 : (m_search_iter) / (1024 * 1024)))), ((m_search_iter) < 10 * 1024 ? ' ' : ((m_search_iter) < 10 * (1024 * 1024) ? 'k' : 'M')),
loc->m_ggc ? "ggc" : "heap");
free (location_string);
}
static inline void
dump_header (const char *name)
{
fprintf (
# 261 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h" 3 4
stderr
# 261 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
, "%-48s %11s%16s%17s%12s%12s%10s\n", name, "Leak", "Peak",
"Times", "N searches", "Search iter", "Type");
}
uint64_t m_nsearches;
uint64_t m_search_iter;
};
extern mem_alloc_description<bitmap_usage> bitmap_mem_desc;
typedef unsigned long BITMAP_WORD;
# 292 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
struct bitmap_obstack {
struct bitmap_element *elements;
bitmap_head *heads;
struct obstack obstack;
};
# 310 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
struct bitmap_element {
struct bitmap_element *next;
struct bitmap_element *prev;
unsigned int indx;
BITMAP_WORD bits[((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u))];
};
class bitmap_head {
public:
static bitmap_obstack crashme;
constexpr bitmap_head()
: indx (0), tree_form (false), padding (0), alloc_descriptor (0), first (nullptr),
current (nullptr), obstack (&crashme)
{}
unsigned int indx;
unsigned tree_form: 1;
unsigned padding: 2;
unsigned alloc_descriptor: 29;
bitmap_element *first;
bitmap_element * current;
bitmap_obstack * obstack;
void dump ();
unsigned *get_descriptor ()
{
return (unsigned *)(ptrdiff_t)(alloc_descriptor << 3);
}
};
extern bitmap_element bitmap_zero_bits;
extern bitmap_obstack bitmap_default_obstack;
void bitmap_list_view (bitmap);
void bitmap_tree_view (bitmap);
extern void bitmap_clear (bitmap);
extern void bitmap_copy (bitmap, const_bitmap);
extern void bitmap_move (bitmap, bitmap);
extern bool bitmap_equal_p (const_bitmap, const_bitmap);
extern bool bitmap_intersect_p (const_bitmap, const_bitmap);
extern bool bitmap_intersect_compl_p (const_bitmap, const_bitmap);
inline bool bitmap_empty_p (const_bitmap map)
{
return !map->first;
}
extern bool bitmap_single_bit_set_p (const_bitmap);
extern unsigned long bitmap_count_bits (const_bitmap);
extern unsigned long bitmap_count_unique_bits (const_bitmap, const_bitmap);
extern void bitmap_and (bitmap, const_bitmap, const_bitmap);
extern bool bitmap_and_into (bitmap, const_bitmap);
extern bool bitmap_and_compl (bitmap, const_bitmap, const_bitmap);
extern bool bitmap_and_compl_into (bitmap, const_bitmap);
extern void bitmap_compl_and_into (bitmap, const_bitmap);
extern void bitmap_clear_range (bitmap, unsigned int, unsigned int);
extern void bitmap_set_range (bitmap, unsigned int, unsigned int);
extern bool bitmap_ior (bitmap, const_bitmap, const_bitmap);
extern bool bitmap_ior_into (bitmap, const_bitmap);
extern bool bitmap_ior_into_and_free (bitmap, bitmap *);
extern void bitmap_xor (bitmap, const_bitmap, const_bitmap);
extern void bitmap_xor_into (bitmap, const_bitmap);
extern bool bitmap_ior_and_into (bitmap DST, const_bitmap B, const_bitmap C);
extern bool bitmap_ior_and_compl (bitmap DST, const_bitmap A,
const_bitmap B, const_bitmap C);
extern bool bitmap_ior_and_compl_into (bitmap A,
const_bitmap B, const_bitmap C);
extern bool bitmap_clear_bit (bitmap, int);
extern bool bitmap_set_bit (bitmap, int);
extern int bitmap_bit_p (const_bitmap, int);
extern void debug_bitmap (const_bitmap);
extern void debug_bitmap_file (FILE *, const_bitmap);
extern void bitmap_print (FILE *, const_bitmap, const char *, const char *);
extern void bitmap_obstack_initialize (bitmap_obstack *);
extern void bitmap_obstack_release (bitmap_obstack *);
extern void bitmap_register (bitmap );
extern void dump_bitmap_statistics (void);
static inline void
bitmap_initialize (bitmap head, bitmap_obstack *obstack )
{
head->first = head->current = nullptr;
head->indx = head->tree_form = 0;
head->padding = 0;
head->alloc_descriptor = 0;
head->obstack = obstack;
if (0)
bitmap_register (head );
}
static inline void
bitmap_release (bitmap head)
{
bitmap_clear (head);
head->obstack = &bitmap_head::crashme;
}
extern bitmap bitmap_alloc (bitmap_obstack *obstack );
extern bitmap bitmap_gc_alloc ();
extern void bitmap_obstack_free (bitmap);
inline void dump_bitmap (FILE *file, const_bitmap map)
{
bitmap_print (file, map, "", "\n");
}
extern void debug (const bitmap_head &ref);
extern void debug (const bitmap_head *ptr);
extern unsigned bitmap_first_set_bit (const_bitmap);
extern unsigned bitmap_last_set_bit (const_bitmap);
extern hashval_t bitmap_hash (const_bitmap);
struct bitmap_iterator
{
bitmap_element *elt1;
bitmap_element *elt2;
unsigned word_no;
BITMAP_WORD bits;
};
static inline void
bmp_iter_set_init (bitmap_iterator *bi, const_bitmap map,
unsigned start_bit, unsigned *bit_no)
{
bi->elt1 = map->first;
bi->elt2 = nullptr;
((void)(!(!map->tree_form) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 535, __FUNCTION__), 0 : 0));
while (1)
{
if (!bi->elt1)
{
bi->elt1 = &bitmap_zero_bits;
break;
}
if (bi->elt1->indx >= start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
break;
bi->elt1 = bi->elt1->next;
}
if (bi->elt1->indx != start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
start_bit = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
bi->word_no = start_bit / (8 * 8 * 1u) % ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u));
bi->bits = bi->elt1->bits[bi->word_no];
bi->bits >>= start_bit % (8 * 8 * 1u);
start_bit += !bi->bits;
*bit_no = start_bit;
}
static inline void
bmp_iter_and_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2,
unsigned start_bit, unsigned *bit_no)
{
bi->elt1 = map1->first;
bi->elt2 = map2->first;
((void)(!(!map1->tree_form && !map2->tree_form) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 579, __FUNCTION__), 0 : 0));
while (1)
{
if (!bi->elt1)
{
bi->elt2 = nullptr;
break;
}
if (bi->elt1->indx >= start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
break;
bi->elt1 = bi->elt1->next;
}
while (1)
{
if (!bi->elt2)
{
bi->elt1 = bi->elt2 = &bitmap_zero_bits;
break;
}
if (bi->elt2->indx >= bi->elt1->indx)
break;
bi->elt2 = bi->elt2->next;
}
if (bi->elt1->indx == bi->elt2->indx)
{
if (bi->elt1->indx != start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
start_bit = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
bi->word_no = start_bit / (8 * 8 * 1u) % ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u));
bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
bi->bits >>= start_bit % (8 * 8 * 1u);
}
else
{
bi->word_no = ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) - 1;
bi->bits = 0;
}
start_bit += !bi->bits;
*bit_no = start_bit;
}
static inline void
bmp_iter_and_compl_init (bitmap_iterator *bi,
const_bitmap map1, const_bitmap map2,
unsigned start_bit, unsigned *bit_no)
{
bi->elt1 = map1->first;
bi->elt2 = map2->first;
((void)(!(!map1->tree_form && !map2->tree_form) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 649, __FUNCTION__), 0 : 0));
while (1)
{
if (!bi->elt1)
{
bi->elt1 = &bitmap_zero_bits;
break;
}
if (bi->elt1->indx >= start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
break;
bi->elt1 = bi->elt1->next;
}
while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
bi->elt2 = bi->elt2->next;
if (bi->elt1->indx != start_bit / (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)))
start_bit = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
bi->word_no = start_bit / (8 * 8 * 1u) % ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u));
bi->bits = bi->elt1->bits[bi->word_no];
if (bi->elt2 && bi->elt1->indx == bi->elt2->indx)
bi->bits &= ~bi->elt2->bits[bi->word_no];
bi->bits >>= start_bit % (8 * 8 * 1u);
start_bit += !bi->bits;
*bit_no = start_bit;
}
static inline void
bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no)
{
bi->bits >>= 1;
*bit_no += 1;
}
static inline void
bmp_iter_next_bit (bitmap_iterator * bi, unsigned *bit_no)
{
{
unsigned int n = __builtin_ctzl (bi->bits);
((void)(!(sizeof (unsigned long) == sizeof (BITMAP_WORD)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 707, __FUNCTION__), 0 : 0));
bi->bits >>= n;
*bit_no += n;
}
}
static inline bool
bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
{
if (bi->bits)
{
next_bit:
bmp_iter_next_bit (bi, bit_no);
return true;
}
*bit_no = ((*bit_no + (8 * 8 * 1u) - 1)
/ (8 * 8 * 1u) * (8 * 8 * 1u));
bi->word_no++;
while (1)
{
while (bi->word_no != ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)))
{
bi->bits = bi->elt1->bits[bi->word_no];
if (bi->bits)
goto next_bit;
*bit_no += (8 * 8 * 1u);
bi->word_no++;
}
((void)(!(bi->elt1->indx != -1U) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 755, __FUNCTION__), 0 : 0));
bi->elt1 = bi->elt1->next;
if (!bi->elt1)
return false;
*bit_no = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
bi->word_no = 0;
}
}
static inline bool
bmp_iter_and (bitmap_iterator *bi, unsigned *bit_no)
{
if (bi->bits)
{
next_bit:
bmp_iter_next_bit (bi, bit_no);
return true;
}
*bit_no = ((*bit_no + (8 * 8 * 1u) - 1)
/ (8 * 8 * 1u) * (8 * 8 * 1u));
bi->word_no++;
while (1)
{
while (bi->word_no != ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)))
{
bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
if (bi->bits)
goto next_bit;
*bit_no += (8 * 8 * 1u);
bi->word_no++;
}
do
{
((void)(!(bi->elt1->indx != -1U) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 804, __FUNCTION__), 0 : 0));
do
{
bi->elt1 = bi->elt1->next;
if (!bi->elt1)
return false;
}
while (bi->elt1->indx < bi->elt2->indx);
((void)(!(bi->elt2->indx != -1U) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 817, __FUNCTION__), 0 : 0));
while (bi->elt2->indx < bi->elt1->indx)
{
bi->elt2 = bi->elt2->next;
if (!bi->elt2)
return false;
}
}
while (bi->elt1->indx != bi->elt2->indx);
*bit_no = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
bi->word_no = 0;
}
}
static inline bool
bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no)
{
if (bi->bits)
{
next_bit:
bmp_iter_next_bit (bi, bit_no);
return true;
}
*bit_no = ((*bit_no + (8 * 8 * 1u) - 1)
/ (8 * 8 * 1u) * (8 * 8 * 1u));
bi->word_no++;
while (1)
{
while (bi->word_no != ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)))
{
bi->bits = bi->elt1->bits[bi->word_no];
if (bi->elt2 && bi->elt2->indx == bi->elt1->indx)
bi->bits &= ~bi->elt2->bits[bi->word_no];
if (bi->bits)
goto next_bit;
*bit_no += (8 * 8 * 1u);
bi->word_no++;
}
((void)(!(bi->elt1->indx != -1U) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 872, __FUNCTION__), 0 : 0));
bi->elt1 = bi->elt1->next;
if (!bi->elt1)
return false;
((void)(!(! bi->elt2 || bi->elt2->indx != -1U) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h", 880, __FUNCTION__), 0 : 0));
while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
bi->elt2 = bi->elt2->next;
*bit_no = bi->elt1->indx * (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u));
bi->word_no = 0;
}
}
# 939 "/home/giulianob/gcc_git_gnu/gcc/gcc/bitmap.h"
class auto_bitmap
{
public:
auto_bitmap () { bitmap_initialize (&m_bits, &bitmap_default_obstack); }
explicit auto_bitmap (bitmap_obstack *o) { bitmap_initialize (&m_bits, o); }
~auto_bitmap () { bitmap_clear (&m_bits); }
operator bitmap () { return &m_bits; }
private:
auto_bitmap (const auto_bitmap &);
auto_bitmap &operator = (const auto_bitmap &);
auto_bitmap (auto_bitmap &&);
auto_bitmap &operator = (auto_bitmap &&);
bitmap_head m_bits;
};
template<typename T, typename Traits = array_traits<T> >
class base_bitmap_view
{
public:
typedef typename Traits::element_type array_element_type;
base_bitmap_view (const T &, bitmap_element *);
operator const_bitmap () const { return &m_head; }
private:
base_bitmap_view (const base_bitmap_view &);
bitmap_head m_head;
};
template<typename T, typename Traits>
class bitmap_view<T, Traits, true> : public base_bitmap_view<T, Traits>
{
public:
bitmap_view (const T &array)
: base_bitmap_view<T, Traits> (array, m_bitmap_elements) {}
private:
static const size_t num_bitmap_elements
= (((8 * sizeof (typename Traits::element_type) * Traits::constant_size) + ((((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u))) - 1) / ((((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u))))
;
bitmap_element m_bitmap_elements[num_bitmap_elements];
};
template<typename T, typename Traits>
base_bitmap_view<T, Traits>::base_bitmap_view (const T &array,
bitmap_element *bitmap_elements)
{
m_head.obstack = nullptr;
const size_t array_element_bits = 8 * sizeof (array_element_type);
static_assert (((((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)) % array_element_bits == 0), "BITMAP_ELEMENT_ALL_BITS % array_element_bits == 0");
size_t array_step = (((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)) * (8 * 8 * 1u)) / array_element_bits;
size_t array_size = Traits::size (array);
const array_element_type *array_elements = Traits::base (array);
unsigned int indx = 0;
for (size_t array_base = 0;
array_base < array_size;
array_base += array_step, indx += 1)
{
unsigned int array_count
= ((__builtin_constant_p (array_size % array_step == 0) && (array_size % array_step == 0))
? array_step : ((array_step) < (array_size - array_base) ? (array_step) : (array_size - array_base)));
array_element_type ior = array_elements[array_base];
for (size_t i = 1; i < array_count; ++i)
ior |= array_elements[array_base + i];
if (ior == 0)
continue;
bitmap_element *bitmap_element = bitmap_elements++;
if (m_head.current)
m_head.current->next = bitmap_element;
else
m_head.first = bitmap_element;
bitmap_element->prev = m_head.current;
bitmap_element->next = nullptr;
bitmap_element->indx = indx;
m_head.current = bitmap_element;
m_head.indx = indx;
if (array_element_bits < (8 * 8 * 1u))
{
size_t array_i = array_base;
for (unsigned int word_i = 0; word_i < ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u));
++word_i)
{
BITMAP_WORD word = 0;
for (unsigned int shift = 0;
shift < (8 * 8 * 1u) && array_i < array_size;
shift += array_element_bits)
word |= array_elements[array_i++] << shift;
bitmap_element->bits[word_i] = word;
}
}
else
{
unsigned int word_i = 0;
for (unsigned int i = 0; i < array_count; ++i)
for (unsigned int shift = 0; shift < array_element_bits;
shift += (8 * 8 * 1u))
bitmap_element->bits[word_i++]
= array_elements[array_base + i] >> shift;
while (word_i < ((128 + (8 * 8 * 1u) - 1) / (8 * 8 * 1u)))
bitmap_element->bits[word_i++] = 0;
}
}
}
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h" 1
# 86 "/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h"
struct simple_bitmap_def
{
unsigned int n_bits;
unsigned int size;
unsigned long elms[1];
};
# 101 "/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h"
static inline void
bitmap_check_index (const_sbitmap map, int index)
{
((void)(!(index >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h", 104, __FUNCTION__), 0 : 0));
((void)(!((unsigned int)index < map->n_bits) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h", 105, __FUNCTION__), 0 : 0));
}
static inline void
bitmap_check_sizes (const_sbitmap a, const_sbitmap b)
{
((void)(!(a->n_bits == b->n_bits) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h", 113, __FUNCTION__), 0 : 0));
}
static inline unsigned long
bitmap_bit_p (const_sbitmap map, int bitno)
{
bitmap_check_index (map, bitno);
size_t i = bitno / ((8 * 8) * 1u);
unsigned int s = bitno % ((8 * 8) * 1u);
return (map->elms[i] >> s) & (unsigned long) 1;
}
static inline void
bitmap_set_bit (sbitmap map, int bitno)
{
bitmap_check_index (map, bitno);
map->elms[bitno / ((8 * 8) * 1u)]
|= (unsigned long) 1 << (bitno) % ((8 * 8) * 1u);
}
static inline void
bitmap_clear_bit (sbitmap map, int bitno)
{
bitmap_check_index (map, bitno);
map->elms[bitno / ((8 * 8) * 1u)]
&= ~((unsigned long) 1 << (bitno) % ((8 * 8) * 1u));
}
struct sbitmap_iterator {
const unsigned long *ptr;
unsigned int size;
unsigned int word_num;
unsigned int bit_num;
unsigned long word;
};
static inline void
bmp_iter_set_init (sbitmap_iterator *i, const_sbitmap bmp,
unsigned int min, unsigned *bit_no __attribute__ ((__unused__)))
{
i->word_num = min / (unsigned int) ((8 * 8) * 1u);
i->bit_num = min;
i->size = bmp->size;
i->ptr = bmp->elms;
if (i->word_num >= i->size)
i->word = 0;
else
i->word = (i->ptr[i->word_num]
>> (i->bit_num % (unsigned int) ((8 * 8) * 1u)));
}
static inline bool
bmp_iter_set (sbitmap_iterator *i, unsigned int *n)
{
for (; i->word == 0; i->word = i->ptr[i->word_num])
{
i->word_num++;
if (i->word_num >= i->size)
return false;
i->bit_num = i->word_num * ((8 * 8) * 1u);
}
for (; (i->word & 1) == 0; i->word >>= 1)
i->bit_num++;
*n = i->bit_num;
return true;
}
static inline void
bmp_iter_next (sbitmap_iterator *i, unsigned *bit_no __attribute__ ((__unused__)))
{
i->word >>= 1;
i->bit_num++;
}
# 235 "/home/giulianob/gcc_git_gnu/gcc/gcc/sbitmap.h"
inline void sbitmap_free (sbitmap map)
{
free (map);
}
inline void sbitmap_vector_free (sbitmap * vec)
{
free (vec);
}
extern void dump_bitmap (FILE *, const_sbitmap);
extern void debug_raw (const simple_bitmap_def &ref);
extern void debug_raw (const simple_bitmap_def *ptr);
extern void dump_bitmap_file (FILE *, const_sbitmap);
extern void debug (const simple_bitmap_def &ref);
extern void debug (const simple_bitmap_def *ptr);
extern void dump_bitmap_vector (FILE *, const char *, const char *, sbitmap *,
int);
extern sbitmap sbitmap_alloc (unsigned int);
extern sbitmap *sbitmap_vector_alloc (unsigned int, unsigned int);
extern sbitmap sbitmap_resize (sbitmap, unsigned int, int);
extern void bitmap_copy (sbitmap, const_sbitmap);
extern int bitmap_equal_p (const_sbitmap, const_sbitmap);
extern unsigned int bitmap_count_bits (const_sbitmap);
extern bool bitmap_empty_p (const_sbitmap);
extern void bitmap_clear (sbitmap);
extern void bitmap_clear_range (sbitmap, unsigned, unsigned);
extern void bitmap_set_range (sbitmap, unsigned, unsigned);
extern void bitmap_ones (sbitmap);
extern void bitmap_vector_clear (sbitmap *, unsigned int);
extern void bitmap_vector_ones (sbitmap *, unsigned int);
extern bool bitmap_ior_and_compl (sbitmap, const_sbitmap,
const_sbitmap, const_sbitmap);
extern void bitmap_and_compl (sbitmap, const_sbitmap, const_sbitmap);
extern void bitmap_not (sbitmap, const_sbitmap);
extern bool bitmap_or_and (sbitmap, const_sbitmap,
const_sbitmap, const_sbitmap);
extern bool bitmap_and_or (sbitmap, const_sbitmap,
const_sbitmap, const_sbitmap);
extern bool bitmap_intersect_p (const_sbitmap, const_sbitmap);
extern bool bitmap_and (sbitmap, const_sbitmap, const_sbitmap);
extern bool bitmap_ior (sbitmap, const_sbitmap, const_sbitmap);
extern bool bitmap_xor (sbitmap, const_sbitmap, const_sbitmap);
extern bool bitmap_subset_p (const_sbitmap, const_sbitmap);
extern bool bitmap_bit_in_range_p (const_sbitmap, unsigned int, unsigned int);
extern int bitmap_first_set_bit (const_sbitmap);
extern int bitmap_last_set_bit (const_sbitmap);
extern void debug_bitmap (const_sbitmap);
extern sbitmap sbitmap_realloc (sbitmap, unsigned int);
class auto_sbitmap
{
public:
explicit auto_sbitmap (unsigned int size) :
m_bitmap (sbitmap_alloc (size)) {}
~auto_sbitmap () { sbitmap_free (m_bitmap); }
operator sbitmap () { return m_bitmap; }
operator const_sbitmap () const { return m_bitmap; }
private:
auto_sbitmap (const auto_sbitmap &);
auto_sbitmap &operator = (const auto_sbitmap &);
auto_sbitmap (auto_sbitmap &&);
auto_sbitmap &operator = (auto_sbitmap &&);
sbitmap m_bitmap;
};
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/profile-count.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h" 2
class edge_def {
public:
basic_block src;
basic_block dest;
union edge_def_insns {
gimple_seq g;
rtx_insn *r;
} insns;
void * aux;
location_t goto_locus;
unsigned int dest_idx;
int flags;
profile_probability probability;
inline profile_count count () const;
};
enum cfg_edge_flags {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg-flags.def" 1
# 111 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg-flags.def"
EDGE_FALLTHRU = 1 << 0 ,
EDGE_ABNORMAL = 1 << 1 ,
EDGE_ABNORMAL_CALL = 1 << 2 ,
EDGE_EH = 1 << 3 ,
EDGE_PRESERVE = 1 << 4 ,
EDGE_FAKE = 1 << 5 ,
EDGE_DFS_BACK = 1 << 6 ,
EDGE_IRREDUCIBLE_LOOP = 1 << 7 ,
EDGE_TRUE_VALUE = 1 << 8 ,
EDGE_FALSE_VALUE = 1 << 9 ,
EDGE_EXECUTABLE = 1 << 10 ,
EDGE_CROSSING = 1 << 11 ,
EDGE_SIBCALL = 1 << 12 ,
EDGE_CAN_FALLTHRU = 1 << 13 ,
EDGE_LOOP_EXIT = 1 << 14 ,
EDGE_TM_UNINSTRUMENTED = 1 << 15 ,
EDGE_TM_ABORT = 1 << 16 ,
EDGE_IGNORE = 1 << 17 ,
# 59 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h" 2
LAST_CFG_EDGE_FLAG
};
# 72 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h"
struct rtl_bb_info {
rtx_insn *end_;
rtx_insn *header_;
rtx_insn *footer_;
};
struct gimple_bb_info {
gimple_seq seq;
gimple_seq phi_nodes;
};
# 117 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h"
struct basic_block_def {
vec<edge, va_gc> *preds;
vec<edge, va_gc> *succs;
void * aux;
class loop *loop_father;
struct et_node * dom[2];
basic_block prev_bb;
basic_block next_bb;
union basic_block_il_dependent {
struct gimple_bb_info gimple;
struct {
rtx_insn *head_;
struct rtl_bb_info * rtl;
} x;
} il;
int flags;
int index;
profile_count count;
int discriminator;
};
typedef int __assert_gimple_bb_smaller_rtl_bb
[(int) sizeof (struct rtl_bb_info)
- (int) sizeof (struct gimple_bb_info)];
enum cfg_bb_flags
{
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg-flags.def" 1
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg-flags.def"
BB_NEW = 1 << 0 ,
BB_REACHABLE = 1 << 1 ,
BB_IRREDUCIBLE_LOOP = 1 << 2 ,
BB_SUPERBLOCK = 1 << 3 ,
BB_DISABLE_SCHEDULE = 1 << 4 ,
BB_HOT_PARTITION = 1 << 5 ,
BB_COLD_PARTITION = 1 << 6 ,
BB_DUPLICATED = 1 << 7 ,
BB_NON_LOCAL_GOTO_TARGET = 1 << 8 ,
BB_RTL = 1 << 9 ,
BB_FORWARDER_BLOCK = 1 << 10 ,
BB_NONTHREADABLE_BLOCK = 1 << 11 ,
BB_MODIFIED = 1 << 12 ,
BB_VISITED = 1 << 13 ,
BB_IN_TRANSACTION = 1 << 14 ,
# 173 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h" 2
LAST_CFG_BB_FLAG
};
# 320 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h"
static inline bool
single_succ_p (const_basic_block bb)
{
return vec_safe_length (bb->succs) == 1;
}
static inline bool
single_pred_p (const_basic_block bb)
{
return vec_safe_length (bb->preds) == 1;
}
static inline edge
single_succ_edge (const_basic_block bb)
{
((void)(!(single_succ_p (bb)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h", 340, __FUNCTION__), 0 : 0));
return (*(bb)->succs)[(0)];
}
static inline edge
single_pred_edge (const_basic_block bb)
{
((void)(!(single_pred_p (bb)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h", 350, __FUNCTION__), 0 : 0));
return (*(bb)->preds)[(0)];
}
static inline basic_block
single_succ (const_basic_block bb)
{
return single_succ_edge (bb)->dest;
}
static inline basic_block
single_pred (const_basic_block bb)
{
return single_pred_edge (bb)->src;
}
struct edge_iterator {
unsigned index;
vec<edge, va_gc> **container;
};
static inline vec<edge, va_gc> *
ei_container (edge_iterator i)
{
((void)(!(i.container) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h", 382, __FUNCTION__), 0 : 0));
return *i.container;
}
static inline edge_iterator
ei_start_1 (vec<edge, va_gc> **ev)
{
edge_iterator i;
i.index = 0;
i.container = ev;
return i;
}
static inline edge_iterator
ei_last_1 (vec<edge, va_gc> **ev)
{
edge_iterator i;
i.index = vec_safe_length (*ev) - 1;
i.container = ev;
return i;
}
static inline bool
ei_end_p (edge_iterator i)
{
return (i.index == vec_safe_length (ei_container (i)));
}
static inline bool
ei_one_before_end_p (edge_iterator i)
{
return (i.index + 1 == vec_safe_length (ei_container (i)));
}
static inline void
ei_next (edge_iterator *i)
{
((void)(!(i->index < vec_safe_length (ei_container (*i))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h", 433, __FUNCTION__), 0 : 0));
i->index++;
}
static inline void
ei_prev (edge_iterator *i)
{
((void)(!(i->index > 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h", 441, __FUNCTION__), 0 : 0));
i->index--;
}
static inline edge
ei_edge (edge_iterator i)
{
return (*ei_container (i))[(i.index)];
}
static inline edge
ei_safe_edge (edge_iterator i)
{
return !ei_end_p (i) ? ei_edge (i) : nullptr;
}
static inline bool
ei_cond (edge_iterator ei, edge *p)
{
if (!ei_end_p (ei))
{
*p = ei_edge (ei);
return 1;
}
else
{
*p = nullptr;
return 0;
}
}
# 516 "/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h"
static inline bool
bb_in_transaction (basic_block bb)
{
return bb->flags & BB_IN_TRANSACTION;
}
static inline bool
bb_has_eh_pred (basic_block bb)
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
if (e->flags & EDGE_EH)
return true;
}
return false;
}
static inline bool
bb_has_abnormal_pred (basic_block bb)
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
if (e->flags & EDGE_ABNORMAL)
return true;
}
return false;
}
static inline edge
find_fallthru_edge (vec<edge, va_gc> *edges)
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((edges))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->flags & EDGE_FALLTHRU)
break;
return e;
}
static inline void
check_probability (int prob)
{
((void)(!(prob >= 0 && prob <= 10000) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/basic-block.h", 571, __FUNCTION__), 0 : 0));
}
static inline int
combine_probabilities (int prob1, int prob2)
{
check_probability (prob1);
check_probability (prob2);
return (((prob1 * prob2) + (10000) / 2) / (10000));
}
static inline gcov_type
apply_scale (gcov_type freq, gcov_type scale)
{
return (((freq * scale) + (10000) / 2) / (10000));
}
static inline gcov_type
apply_probability (gcov_type freq, int prob)
{
check_probability (prob);
return apply_scale (freq, prob);
}
static inline int
inverse_probability (int prob1)
{
check_probability (prob1);
return 10000 - prob1;
}
static inline bool
has_abnormal_or_eh_outgoing_edge_p (basic_block bb)
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
return true;
return false;
}
static inline bool
has_abnormal_call_or_eh_pred_edge_p (basic_block bb)
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
return true;
return false;
}
inline profile_count edge_def::count () const
{
return src->count.apply_probability (probability);
}
# 33 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/dominance.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/dominance.h"
enum cdi_direction
{
CDI_DOMINATORS = 1,
CDI_POST_DOMINATORS = 2
};
enum dom_state
{
DOM_NONE,
DOM_NO_FAST_QUERY,
DOM_OK
};
extern void calculate_dominance_info (enum cdi_direction);
extern void calculate_dominance_info_for_region (enum cdi_direction,
vec<basic_block>);
extern void free_dominance_info (function *, enum cdi_direction);
extern void free_dominance_info (enum cdi_direction);
extern void free_dominance_info_for_region (function *,
enum cdi_direction,
vec<basic_block>);
extern basic_block get_immediate_dominator (enum cdi_direction, basic_block);
extern void set_immediate_dominator (enum cdi_direction, basic_block,
basic_block);
extern vec<basic_block> get_dominated_by (enum cdi_direction, basic_block);
extern vec<basic_block> get_dominated_by_region (enum cdi_direction,
basic_block *,
unsigned);
extern vec<basic_block> get_dominated_to_depth (enum cdi_direction,
basic_block, int);
extern vec<basic_block> get_all_dominated_blocks (enum cdi_direction,
basic_block);
extern void redirect_immediate_dominators (enum cdi_direction, basic_block,
basic_block);
extern basic_block nearest_common_dominator (enum cdi_direction,
basic_block, basic_block);
extern basic_block nearest_common_dominator_for_set (enum cdi_direction,
bitmap);
extern bool dominated_by_p (enum cdi_direction, const_basic_block,
const_basic_block);
unsigned bb_dom_dfs_in (enum cdi_direction, basic_block);
unsigned bb_dom_dfs_out (enum cdi_direction, basic_block);
extern void verify_dominators (enum cdi_direction);
static inline void
checking_verify_dominators (cdi_direction dir)
{
if (global_options.x_flag_checking)
verify_dominators (dir);
}
basic_block recompute_dominator (enum cdi_direction, basic_block);
extern void iterate_fix_dominators (enum cdi_direction,
vec<basic_block> , bool);
extern void add_to_dominance_info (enum cdi_direction, basic_block);
extern void delete_from_dominance_info (enum cdi_direction, basic_block);
extern basic_block first_dom_son (enum cdi_direction, basic_block);
extern basic_block next_dom_son (enum cdi_direction, basic_block);
extern enum dom_state dom_info_state (function *, enum cdi_direction);
extern enum dom_state dom_info_state (enum cdi_direction);
extern void set_dom_info_availability (enum cdi_direction, enum dom_state);
extern bool dom_info_available_p (function *, enum cdi_direction);
extern bool dom_info_available_p (enum cdi_direction);
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h" 2
enum profile_status_d
{
PROFILE_ABSENT,
PROFILE_GUESSED,
PROFILE_READ,
PROFILE_LAST
};
struct control_flow_graph {
basic_block x_entry_block_ptr;
basic_block x_exit_block_ptr;
vec<basic_block, va_gc> *x_basic_block_info;
int x_n_basic_blocks;
int x_n_edges;
int x_last_basic_block;
int last_label_uid;
vec<basic_block, va_gc> *x_label_to_block_map;
enum profile_status_d x_profile_status;
enum dom_state x_dom_computed[2];
unsigned x_n_bbs_in_dom_tree[2];
int max_jumptable_ents;
profile_count count_max;
int edge_flags_allocated;
int bb_flags_allocated;
};
extern void init_flow (function *);
extern void clear_edges (function *);
extern basic_block alloc_block (void);
extern void link_block (basic_block, basic_block);
extern void unlink_block (basic_block);
extern void compact_blocks (void);
extern void expunge_block (basic_block);
extern edge unchecked_make_edge (basic_block, basic_block, int);
extern edge cached_make_edge (sbitmap, basic_block, basic_block, int);
extern edge make_edge (basic_block, basic_block, int);
extern edge make_single_succ_edge (basic_block, basic_block, int);
extern void remove_edge_raw (edge);
extern void redirect_edge_succ (edge, basic_block);
extern void redirect_edge_pred (edge, basic_block);
extern void clear_bb_flags (void);
extern void dump_edge_info (FILE *, edge, dump_flags_t, int);
extern void debug (edge_def &ref);
extern void debug (edge_def *ptr);
extern void alloc_aux_for_blocks (int);
extern void clear_aux_for_blocks (void);
extern void free_aux_for_blocks (void);
extern void alloc_aux_for_edge (edge, int);
extern void alloc_aux_for_edges (int);
extern void clear_aux_for_edges (void);
extern void free_aux_for_edges (void);
extern void debug_bb (basic_block);
extern basic_block debug_bb_n (int);
extern void dump_bb_info (FILE *, basic_block, int, dump_flags_t, bool, bool);
extern void brief_dump_cfg (FILE *, dump_flags_t);
extern void update_bb_profile_for_threading (basic_block, profile_count, edge);
extern void scale_bbs_frequencies_profile_count (basic_block *, int,
profile_count, profile_count);
extern void scale_bbs_frequencies (basic_block *, int, profile_probability);
extern void initialize_original_copy_tables (void);
extern void reset_original_copy_tables (void);
extern void free_original_copy_tables (void);
extern bool original_copy_tables_initialized_p (void);
extern void set_bb_original (basic_block, basic_block);
extern basic_block get_bb_original (basic_block);
extern void set_bb_copy (basic_block, basic_block);
extern basic_block get_bb_copy (basic_block);
void set_loop_copy (class loop *, class loop *);
class loop *get_loop_copy (class loop *);
template <class T>
class auto_flag
{
public:
auto_flag (T *sptr)
{
m_sptr = sptr;
int free_bit = ffs_hwi (~*sptr);
if (free_bit == 0)
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h", 143, __FUNCTION__));
m_flag = 1UL << (free_bit - 1);
if (m_flag == 0)
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h", 150, __FUNCTION__));
((void)(!((*sptr & m_flag) == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h", 151, __FUNCTION__), 0 : 0));
*sptr |= m_flag;
}
~auto_flag ()
{
((void)(!((*m_sptr & m_flag) == m_flag) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/cfg.h", 156, __FUNCTION__), 0 : 0));
*m_sptr &= ~m_flag;
}
operator T () const { return m_flag; }
private:
T *m_sptr;
T m_flag;
};
class auto_edge_flag : public auto_flag<int>
{
public:
auto_edge_flag (function *fun)
: auto_flag<int> (&fun->cfg->edge_flags_allocated) {}
};
class auto_bb_flag : public auto_flag<int>
{
public:
auto_bb_flag (function *fun)
: auto_flag<int> (&fun->cfg->bb_flags_allocated) {}
};
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/backend.h" 2
# 97 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.h" 1
# 51 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.h"
# 1 "./insn-codes.h" 1
enum insn_code {
CODE_FOR_nothing = 0,
CODE_FOR_x86_sahf_1 = 41,
CODE_FOR_insvhi_1 = 108,
CODE_FOR_insvsi_1 = 109,
CODE_FOR_insvdi_1 = 110,
CODE_FOR_zero_extendqidi2 = 139,
CODE_FOR_zero_extendhidi2 = 140,
CODE_FOR_zero_extendqisi2_and = 141,
CODE_FOR_zero_extendhisi2_and = 142,
CODE_FOR_zero_extendqihi2_and = 145,
CODE_FOR_extendsidi2_1 = 148,
CODE_FOR_extendqidi2 = 149,
CODE_FOR_extendhidi2 = 150,
CODE_FOR_extendhisi2 = 151,
CODE_FOR_extendqisi2 = 153,
CODE_FOR_extendqihi2 = 155,
CODE_FOR_truncdfsf2 = 159,
CODE_FOR_truncxfsf2 = 160,
CODE_FOR_truncxfdf2 = 161,
CODE_FOR_fixuns_truncsfdi2 = 162,
CODE_FOR_fixuns_truncdfdi2 = 163,
CODE_FOR_fixuns_truncsfsi2_avx512f = 164,
CODE_FOR_fixuns_truncdfsi2_avx512f = 165,
CODE_FOR_fix_truncsfsi_sse = 170,
CODE_FOR_fix_truncsfdi_sse = 171,
CODE_FOR_fix_truncdfsi_sse = 172,
CODE_FOR_fix_truncdfdi_sse = 173,
CODE_FOR_fix_trunchi_i387_fisttp = 174,
CODE_FOR_fix_truncsi_i387_fisttp = 175,
CODE_FOR_fix_truncdi_i387_fisttp = 176,
CODE_FOR_fix_truncdi_i387 = 180,
CODE_FOR_fix_trunchi_i387 = 181,
CODE_FOR_fix_truncsi_i387 = 182,
CODE_FOR_x86_fnstcw_1 = 183,
CODE_FOR_floathisf2 = 184,
CODE_FOR_floathidf2 = 185,
CODE_FOR_floathixf2 = 186,
CODE_FOR_floatsixf2 = 187,
CODE_FOR_floatdixf2 = 188,
CODE_FOR_floatdisf2_i387_with_xmm = 195,
CODE_FOR_floatdidf2_i387_with_xmm = 196,
CODE_FOR_floatdixf2_i387_with_xmm = 197,
CODE_FOR_floatunssisf2_i387_with_xmm = 202,
CODE_FOR_floatunssidf2_i387_with_xmm = 203,
CODE_FOR_floatunssixf2_i387_with_xmm = 204,
CODE_FOR_addsi_1_zext = 211,
CODE_FOR_addvqi4_1 = 244,
CODE_FOR_addvhi4_1 = 245,
CODE_FOR_addvsi4_1 = 246,
CODE_FOR_addvdi4_1 = 247,
CODE_FOR_subvqi4_1 = 296,
CODE_FOR_subvhi4_1 = 297,
CODE_FOR_subvsi4_1 = 298,
CODE_FOR_subvdi4_1 = 299,
CODE_FOR_addqi3_carry = 317,
CODE_FOR_addhi3_carry = 318,
CODE_FOR_addsi3_carry = 319,
CODE_FOR_adddi3_carry = 320,
CODE_FOR_addcarrysi = 327,
CODE_FOR_addcarrydi = 328,
CODE_FOR_subqi3_carry = 331,
CODE_FOR_subhi3_carry = 332,
CODE_FOR_subsi3_carry = 333,
CODE_FOR_subdi3_carry = 334,
CODE_FOR_subsi3_carry_ccc = 341,
CODE_FOR_subdi3_carry_ccc = 342,
CODE_FOR_subsi3_carry_ccgz = 345,
CODE_FOR_subdi3_carry_ccgz = 346,
CODE_FOR_subborrowsi = 347,
CODE_FOR_subborrowdi = 348,
CODE_FOR_divmodsi4_1 = 435,
CODE_FOR_divmoddi4_1 = 436,
CODE_FOR_udivmodsi4_1 = 437,
CODE_FOR_udivmoddi4_1 = 438,
CODE_FOR_divmodsi4_zext_1 = 439,
CODE_FOR_udivmodsi4_zext_1 = 440,
CODE_FOR_divmodsi4_zext_2 = 441,
CODE_FOR_udivmodsi4_zext_2 = 442,
CODE_FOR_divmodhiqi3 = 467,
CODE_FOR_udivmodhiqi3 = 468,
CODE_FOR_copysignsf3_const = 610,
CODE_FOR_copysigndf3_const = 611,
CODE_FOR_copysigntf3_const = 612,
CODE_FOR_copysignsf3_var = 613,
CODE_FOR_copysigndf3_var = 614,
CODE_FOR_copysigntf3_var = 615,
CODE_FOR_xorsignsf3_1 = 616,
CODE_FOR_xorsigndf3_1 = 617,
CODE_FOR_x86_64_shld = 635,
CODE_FOR_x86_shld = 636,
CODE_FOR_x86_64_shrd = 680,
CODE_FOR_x86_shrd = 681,
CODE_FOR_ashrsi3_cvt = 682,
CODE_FOR_ashrdi3_cvt = 683,
CODE_FOR_ix86_rotldi3_doubleword = 731,
CODE_FOR_ix86_rotlti3_doubleword = 732,
CODE_FOR_ix86_rotrdi3_doubleword = 733,
CODE_FOR_ix86_rotrti3_doubleword = 734,
CODE_FOR_setcc_sf_sse = 786,
CODE_FOR_setcc_df_sse = 787,
CODE_FOR_jump = 789,
CODE_FOR_blockage = 816,
CODE_FOR_prologue_use = 818,
CODE_FOR_simple_return_internal = 819,
CODE_FOR_interrupt_return = 820,
CODE_FOR_simple_return_internal_long = 821,
CODE_FOR_simple_return_pop_internal = 822,
CODE_FOR_nop = 825,
CODE_FOR_nops = 826,
CODE_FOR_pad = 827,
CODE_FOR_set_got_rex64 = 830,
CODE_FOR_set_rip_rex64 = 831,
CODE_FOR_set_got_offset_rex64 = 832,
CODE_FOR_eh_return_internal = 833,
CODE_FOR_split_stack_return = 836,
CODE_FOR_ffssi2_no_cmove = 837,
CODE_FOR_ctzsi2 = 844,
CODE_FOR_ctzdi2 = 845,
CODE_FOR_bsr_rex64 = 850,
CODE_FOR_bsr = 851,
CODE_FOR_clzsi2_lzcnt = 853,
CODE_FOR_clzdi2_lzcnt = 854,
CODE_FOR_tzcnt_si = 860,
CODE_FOR_lzcnt_si = 861,
CODE_FOR_tzcnt_di = 862,
CODE_FOR_lzcnt_di = 863,
CODE_FOR_tzcnt_hi = 868,
CODE_FOR_lzcnt_hi = 869,
CODE_FOR_bmi_bextr_si = 870,
CODE_FOR_bmi_bextr_di = 871,
CODE_FOR_bmi2_pdep_si3 = 894,
CODE_FOR_bmi2_pdep_di3 = 895,
CODE_FOR_bmi2_pext_si3 = 896,
CODE_FOR_bmi2_pext_di3 = 897,
CODE_FOR_popcountsi2 = 918,
CODE_FOR_popcountdi2 = 919,
CODE_FOR_popcounthi2 = 925,
CODE_FOR_bswaphi_lowpart = 931,
CODE_FOR_parityhi2_cmp = 932,
CODE_FOR_parityqi2_cmp = 933,
CODE_FOR_tls_initial_exec_64_sun = CODE_FOR_nothing,
CODE_FOR_truncxfsf2_i387_noop_unspec = 986,
CODE_FOR_truncxfdf2_i387_noop_unspec = 987,
CODE_FOR_sqrtxf2 = 988,
CODE_FOR_x86_fnstsw_1 = 992,
CODE_FOR_fpremxf4_i387 = 993,
CODE_FOR_fprem1xf4_i387 = 994,
CODE_FOR_sinxf2 = 995,
CODE_FOR_cosxf2 = 996,
CODE_FOR_sincosxf3 = 997,
CODE_FOR_fptanxf4_i387 = 998,
CODE_FOR_atan2xf3 = 999,
CODE_FOR_fyl2xxf3_i387 = 1000,
CODE_FOR_fyl2xp1xf3_i387 = 1001,
CODE_FOR_fxtractxf3_i387 = 1002,
CODE_FOR_fscalexf4_i387 = 1004,
CODE_FOR_sse4_1_roundsf2 = 1005,
CODE_FOR_sse4_1_rounddf2 = 1006,
CODE_FOR_rintxf2 = 1007,
CODE_FOR_lrintxfdi2 = 1008,
CODE_FOR_lrintxfhi2 = 1009,
CODE_FOR_lrintxfsi2 = 1010,
CODE_FOR_frndintxf2_roundeven = 1011,
CODE_FOR_frndintxf2_floor = 1012,
CODE_FOR_frndintxf2_ceil = 1013,
CODE_FOR_frndintxf2_trunc = 1014,
CODE_FOR_frndintxf2_roundeven_i387 = 1015,
CODE_FOR_frndintxf2_floor_i387 = 1016,
CODE_FOR_frndintxf2_ceil_i387 = 1017,
CODE_FOR_frndintxf2_trunc_i387 = 1018,
CODE_FOR_fistdi2_floor = 1025,
CODE_FOR_fistdi2_ceil = 1026,
CODE_FOR_fisthi2_floor = 1027,
CODE_FOR_fisthi2_ceil = 1028,
CODE_FOR_fistsi2_floor = 1029,
CODE_FOR_fistsi2_ceil = 1030,
CODE_FOR_fxamsf2_i387 = 1031,
CODE_FOR_fxamdf2_i387 = 1032,
CODE_FOR_fxamxf2_i387 = 1033,
CODE_FOR_movmsk_df = 1034,
CODE_FOR_cld = 1035,
CODE_FOR_smaxsf3 = 1088,
CODE_FOR_sminsf3 = 1089,
CODE_FOR_smaxdf3 = 1090,
CODE_FOR_smindf3 = 1091,
CODE_FOR_pro_epilogue_adjust_stack_add_si = 1112,
CODE_FOR_pro_epilogue_adjust_stack_add_di = 1113,
CODE_FOR_pro_epilogue_adjust_stack_sub_si = 1114,
CODE_FOR_pro_epilogue_adjust_stack_sub_di = 1115,
CODE_FOR_allocate_stack_worker_probe_si = 1116,
CODE_FOR_allocate_stack_worker_probe_di = 1117,
CODE_FOR_probe_stack_1_si = 1118,
CODE_FOR_probe_stack_1_di = 1119,
CODE_FOR_adjust_stack_and_probe_si = 1120,
CODE_FOR_adjust_stack_and_probe_di = 1121,
CODE_FOR_probe_stack_range_si = 1122,
CODE_FOR_probe_stack_range_di = 1123,
CODE_FOR_trap = 1124,
CODE_FOR_ud2 = 1125,
CODE_FOR_stack_protect_set_1_si = 1129,
CODE_FOR_stack_protect_set_1_di = 1130,
CODE_FOR_stack_protect_test_1_si = 1134,
CODE_FOR_stack_protect_test_1_di = 1135,
CODE_FOR_sse4_2_crc32qi = 1136,
CODE_FOR_sse4_2_crc32hi = 1137,
CODE_FOR_sse4_2_crc32si = 1138,
CODE_FOR_sse4_2_crc32di = 1139,
CODE_FOR_rdpmc = 1140,
CODE_FOR_rdpmc_rex64 = 1141,
CODE_FOR_rdtsc = 1142,
CODE_FOR_rdtsc_rex64 = 1143,
CODE_FOR_rdtscp = 1144,
CODE_FOR_rdtscp_rex64 = 1145,
CODE_FOR_fxsave = 1146,
CODE_FOR_fxsave64 = 1147,
CODE_FOR_fxrstor = 1148,
CODE_FOR_fxrstor64 = 1149,
CODE_FOR_xsave = 1150,
CODE_FOR_xsaveopt = 1151,
CODE_FOR_xsavec = 1152,
CODE_FOR_xsaves = 1153,
CODE_FOR_xsave_rex64 = 1154,
CODE_FOR_xsaveopt_rex64 = 1155,
CODE_FOR_xsavec_rex64 = 1156,
CODE_FOR_xsaves_rex64 = 1157,
CODE_FOR_xsave64 = 1158,
CODE_FOR_xsaveopt64 = 1159,
CODE_FOR_xsavec64 = 1160,
CODE_FOR_xsaves64 = 1161,
CODE_FOR_xrstor = 1162,
CODE_FOR_xrstors = 1163,
CODE_FOR_xrstor_rex64 = 1164,
CODE_FOR_xrstors_rex64 = 1165,
CODE_FOR_xrstor64 = 1166,
CODE_FOR_xrstors64 = 1167,
CODE_FOR_xsetbv = 1168,
CODE_FOR_xsetbv_rex64 = 1169,
CODE_FOR_xgetbv = 1170,
CODE_FOR_xgetbv_rex64 = 1171,
CODE_FOR_fnstenv = 1172,
CODE_FOR_fldenv = 1173,
CODE_FOR_fnstsw = 1174,
CODE_FOR_fnclex = 1175,
CODE_FOR_lwp_llwpcbsi = 1176,
CODE_FOR_lwp_llwpcbdi = 1177,
CODE_FOR_lwp_slwpcbsi = 1178,
CODE_FOR_lwp_slwpcbdi = 1179,
CODE_FOR_lwp_lwpvalsi = 1180,
CODE_FOR_lwp_lwpvaldi = 1181,
CODE_FOR_lwp_lwpinssi = 1182,
CODE_FOR_lwp_lwpinsdi = 1183,
CODE_FOR_rdfsbasesi = 1184,
CODE_FOR_rdgsbasesi = 1185,
CODE_FOR_rdfsbasedi = 1186,
CODE_FOR_rdgsbasedi = 1187,
CODE_FOR_wrfsbasesi = 1188,
CODE_FOR_wrgsbasesi = 1189,
CODE_FOR_wrfsbasedi = 1190,
CODE_FOR_wrgsbasedi = 1191,
CODE_FOR_ptwritesi = 1192,
CODE_FOR_ptwritedi = 1193,
CODE_FOR_rdrandhi_1 = 1194,
CODE_FOR_rdrandsi_1 = 1195,
CODE_FOR_rdranddi_1 = 1196,
CODE_FOR_rdseedhi_1 = 1197,
CODE_FOR_rdseedsi_1 = 1198,
CODE_FOR_rdseeddi_1 = 1199,
CODE_FOR_rdsspsi = 1201,
CODE_FOR_rdsspdi = 1202,
CODE_FOR_incsspsi = 1203,
CODE_FOR_incsspdi = 1204,
CODE_FOR_saveprevssp = 1205,
CODE_FOR_rstorssp = 1206,
CODE_FOR_wrsssi = 1207,
CODE_FOR_wrssdi = 1208,
CODE_FOR_wrusssi = 1209,
CODE_FOR_wrussdi = 1210,
CODE_FOR_setssbsy = 1211,
CODE_FOR_clrssbsy = 1212,
CODE_FOR_nop_endbr = 1213,
CODE_FOR_xbegin_1 = 1214,
CODE_FOR_xend = 1215,
CODE_FOR_xabort = 1216,
CODE_FOR_xtest_1 = 1217,
CODE_FOR_clwb = 1218,
CODE_FOR_clflushopt = 1219,
CODE_FOR_mwaitx = 1220,
CODE_FOR_monitorx_si = 1221,
CODE_FOR_monitorx_di = 1222,
CODE_FOR_clzero_si = 1223,
CODE_FOR_clzero_di = 1224,
CODE_FOR_rdpid = 1227,
CODE_FOR_rdpid_rex64 = 1228,
CODE_FOR_wbinvd = 1229,
CODE_FOR_wbnoinvd = 1230,
CODE_FOR_movdirisi = 1231,
CODE_FOR_movdiridi = 1232,
CODE_FOR_movdir64b_si = 1233,
CODE_FOR_movdir64b_di = 1234,
CODE_FOR_xsusldtrk = 1235,
CODE_FOR_xresldtrk = 1236,
CODE_FOR_enqcmd_si = 1237,
CODE_FOR_enqcmds_si = 1238,
CODE_FOR_enqcmd_di = 1239,
CODE_FOR_enqcmds_di = 1240,
CODE_FOR_umwait = 1241,
CODE_FOR_umwait_rex64 = 1242,
CODE_FOR_umonitor_si = 1243,
CODE_FOR_umonitor_di = 1244,
CODE_FOR_tpause = 1245,
CODE_FOR_tpause_rex64 = 1246,
CODE_FOR_cldemote = 1247,
CODE_FOR_speculation_barrier = 1248,
CODE_FOR_serialize = 1249,
CODE_FOR_patchable_area = 1250,
CODE_FOR_sse_movntq = 1256,
CODE_FOR_mmx_ieee_maxv2sf3 = 1265,
CODE_FOR_mmx_ieee_minv2sf3 = 1266,
CODE_FOR_mmx_rcpv2sf2 = 1267,
CODE_FOR_mmx_rcpit1v2sf3 = 1268,
CODE_FOR_mmx_rcpit2v2sf3 = 1269,
CODE_FOR_sqrtv2sf2 = 1270,
CODE_FOR_mmx_rsqrtv2sf2 = 1271,
CODE_FOR_mmx_rsqit1v2sf3 = 1272,
CODE_FOR_mmx_hsubv2sf3 = 1275,
CODE_FOR_mmx_gtv2sf3 = 1279,
CODE_FOR_mmx_gev2sf3 = 1280,
CODE_FOR_fmav2sf4 = 1285,
CODE_FOR_fmsv2sf4 = 1286,
CODE_FOR_fnmav2sf4 = 1287,
CODE_FOR_fnmsv2sf4 = 1288,
CODE_FOR_mmx_fix_truncv2sfv2si2 = 1289,
CODE_FOR_fixuns_truncv2sfv2si2 = 1290,
CODE_FOR_mmx_floatv2siv2sf2 = 1291,
CODE_FOR_floatunsv2siv2sf2 = 1292,
CODE_FOR_mmx_pf2iw = 1293,
CODE_FOR_mmx_pi2fw = 1294,
CODE_FOR_mmx_pswapdv2sf2 = 1295,
CODE_FOR_mmx_ashrv4hi3 = 1329,
CODE_FOR_mmx_ashrv2si3 = 1330,
CODE_FOR_mmx_ashlv4hi3 = 1331,
CODE_FOR_mmx_lshrv4hi3 = 1332,
CODE_FOR_mmx_ashlv2si3 = 1333,
CODE_FOR_mmx_lshrv2si3 = 1334,
CODE_FOR_mmx_ashlv1di3 = 1335,
CODE_FOR_mmx_lshrv1di3 = 1336,
CODE_FOR_mmx_gtv8qi3 = 1340,
CODE_FOR_mmx_gtv4hi3 = 1341,
CODE_FOR_mmx_gtv2si3 = 1342,
CODE_FOR_mmx_andnotv8qi3 = 1343,
CODE_FOR_mmx_andnotv4hi3 = 1344,
CODE_FOR_mmx_andnotv2si3 = 1345,
CODE_FOR_mmx_packsswb = 1355,
CODE_FOR_mmx_packuswb = 1356,
CODE_FOR_mmx_packssdw = 1357,
CODE_FOR_mmx_punpckhbw = 1358,
CODE_FOR_mmx_punpcklbw = 1359,
CODE_FOR_mmx_punpckhwd = 1360,
CODE_FOR_mmx_punpcklwd = 1361,
CODE_FOR_mmx_punpckhdq = 1362,
CODE_FOR_mmx_punpckldq = 1363,
CODE_FOR_mmx_pshufw_1 = 1374,
CODE_FOR_mmx_pswapdv2si2 = 1376,
CODE_FOR_mmx_psadbw = 1388,
CODE_FOR_mmx_pmovmskb = 1389,
CODE_FOR_movv64qi_internal = 1394,
CODE_FOR_movv32qi_internal = 1395,
CODE_FOR_movv16qi_internal = 1396,
CODE_FOR_movv32hi_internal = 1397,
CODE_FOR_movv16hi_internal = 1398,
CODE_FOR_movv8hi_internal = 1399,
CODE_FOR_movv16si_internal = 1400,
CODE_FOR_movv8si_internal = 1401,
CODE_FOR_movv4si_internal = 1402,
CODE_FOR_movv8di_internal = 1403,
CODE_FOR_movv4di_internal = 1404,
CODE_FOR_movv2di_internal = 1405,
CODE_FOR_movv4ti_internal = 1406,
CODE_FOR_movv2ti_internal = 1407,
CODE_FOR_movv1ti_internal = 1408,
CODE_FOR_movv16sf_internal = 1409,
CODE_FOR_movv8sf_internal = 1410,
CODE_FOR_movv4sf_internal = 1411,
CODE_FOR_movv8df_internal = 1412,
CODE_FOR_movv4df_internal = 1413,
CODE_FOR_movv2df_internal = 1414,
CODE_FOR_avx512f_loadv16si_mask = 1415,
CODE_FOR_avx512vl_loadv8si_mask = 1416,
CODE_FOR_avx512vl_loadv4si_mask = 1417,
CODE_FOR_avx512f_loadv8di_mask = 1418,
CODE_FOR_avx512vl_loadv4di_mask = 1419,
CODE_FOR_avx512vl_loadv2di_mask = 1420,
CODE_FOR_avx512f_loadv16sf_mask = 1421,
CODE_FOR_avx512vl_loadv8sf_mask = 1422,
CODE_FOR_avx512vl_loadv4sf_mask = 1423,
CODE_FOR_avx512f_loadv8df_mask = 1424,
CODE_FOR_avx512vl_loadv4df_mask = 1425,
CODE_FOR_avx512vl_loadv2df_mask = 1426,
CODE_FOR_avx512bw_loadv64qi_mask = 1427,
CODE_FOR_avx512vl_loadv16qi_mask = 1428,
CODE_FOR_avx512vl_loadv32qi_mask = 1429,
CODE_FOR_avx512bw_loadv32hi_mask = 1430,
CODE_FOR_avx512vl_loadv16hi_mask = 1431,
CODE_FOR_avx512vl_loadv8hi_mask = 1432,
CODE_FOR_avx512f_movsf_mask = 1433,
CODE_FOR_avx512f_movdf_mask = 1434,
CODE_FOR_avx512f_storesf_mask = 1437,
CODE_FOR_avx512f_storedf_mask = 1438,
CODE_FOR_avx512f_storev16si_mask = 1439,
CODE_FOR_avx512vl_storev8si_mask = 1440,
CODE_FOR_avx512vl_storev4si_mask = 1441,
CODE_FOR_avx512f_storev8di_mask = 1442,
CODE_FOR_avx512vl_storev4di_mask = 1443,
CODE_FOR_avx512vl_storev2di_mask = 1444,
CODE_FOR_avx512f_storev16sf_mask = 1445,
CODE_FOR_avx512vl_storev8sf_mask = 1446,
CODE_FOR_avx512vl_storev4sf_mask = 1447,
CODE_FOR_avx512f_storev8df_mask = 1448,
CODE_FOR_avx512vl_storev4df_mask = 1449,
CODE_FOR_avx512vl_storev2df_mask = 1450,
CODE_FOR_avx512bw_storev64qi_mask = 1451,
CODE_FOR_avx512vl_storev16qi_mask = 1452,
CODE_FOR_avx512vl_storev32qi_mask = 1453,
CODE_FOR_avx512bw_storev32hi_mask = 1454,
CODE_FOR_avx512vl_storev16hi_mask = 1455,
CODE_FOR_avx512vl_storev8hi_mask = 1456,
CODE_FOR_sse2_movq128 = 1457,
CODE_FOR_movdi_to_sse = 1458,
CODE_FOR_avx_lddqu256 = 1459,
CODE_FOR_sse3_lddqu = 1460,
CODE_FOR_sse2_movntisi = 1461,
CODE_FOR_sse2_movntidi = 1462,
CODE_FOR_avx512f_movntv16sf = 1463,
CODE_FOR_avx_movntv8sf = 1464,
CODE_FOR_sse_movntv4sf = 1465,
CODE_FOR_avx512f_movntv8df = 1466,
CODE_FOR_avx_movntv4df = 1467,
CODE_FOR_sse2_movntv2df = 1468,
CODE_FOR_avx512f_movntv8di = 1469,
CODE_FOR_avx_movntv4di = 1470,
CODE_FOR_sse2_movntv2di = 1471,
CODE_FOR_kandqi = 1472,
CODE_FOR_kiorqi = 1473,
CODE_FOR_kxorqi = 1474,
CODE_FOR_kandhi = 1475,
CODE_FOR_kiorhi = 1476,
CODE_FOR_kxorhi = 1477,
CODE_FOR_kandsi = 1478,
CODE_FOR_kiorsi = 1479,
CODE_FOR_kxorsi = 1480,
CODE_FOR_kanddi = 1481,
CODE_FOR_kiordi = 1482,
CODE_FOR_kxordi = 1483,
CODE_FOR_kandnqi = 1484,
CODE_FOR_kandnhi = 1485,
CODE_FOR_kandnsi = 1486,
CODE_FOR_kandndi = 1487,
CODE_FOR_kxnorqi = 1488,
CODE_FOR_kxnorhi = 1489,
CODE_FOR_kxnorsi = 1490,
CODE_FOR_kxnordi = 1491,
CODE_FOR_knotqi = 1492,
CODE_FOR_knothi = 1493,
CODE_FOR_knotsi = 1494,
CODE_FOR_knotdi = 1495,
CODE_FOR_kaddqi = 1496,
CODE_FOR_kaddhi = 1497,
CODE_FOR_kaddsi = 1498,
CODE_FOR_kadddi = 1499,
CODE_FOR_kashiftqi = 1500,
CODE_FOR_klshiftrtqi = 1501,
CODE_FOR_kashifthi = 1502,
CODE_FOR_klshiftrthi = 1503,
CODE_FOR_kashiftsi = 1504,
CODE_FOR_klshiftrtsi = 1505,
CODE_FOR_kashiftdi = 1506,
CODE_FOR_klshiftrtdi = 1507,
CODE_FOR_ktestqi = 1508,
CODE_FOR_ktesthi = 1509,
CODE_FOR_ktestsi = 1510,
CODE_FOR_ktestdi = 1511,
CODE_FOR_kortestqi = 1512,
CODE_FOR_kortesthi = 1513,
CODE_FOR_kortestsi = 1514,
CODE_FOR_kortestdi = 1515,
CODE_FOR_kunpckhi = 1516,
CODE_FOR_kunpcksi = 1517,
CODE_FOR_kunpckdi = 1518,
CODE_FOR_sse_vmaddv4sf3 = 1613,
CODE_FOR_sse_vmaddv4sf3_round = 1614,
CODE_FOR_sse_vmaddv4sf3_mask = 1615,
CODE_FOR_sse_vmaddv4sf3_mask_round = 1616,
CODE_FOR_sse_vmsubv4sf3 = 1617,
CODE_FOR_sse_vmsubv4sf3_round = 1618,
CODE_FOR_sse_vmsubv4sf3_mask = 1619,
CODE_FOR_sse_vmsubv4sf3_mask_round = 1620,
CODE_FOR_sse2_vmaddv2df3 = 1621,
CODE_FOR_sse2_vmaddv2df3_round = 1622,
CODE_FOR_sse2_vmaddv2df3_mask = 1623,
CODE_FOR_sse2_vmaddv2df3_mask_round = 1624,
CODE_FOR_sse2_vmsubv2df3 = 1625,
CODE_FOR_sse2_vmsubv2df3_round = 1626,
CODE_FOR_sse2_vmsubv2df3_mask = 1627,
CODE_FOR_sse2_vmsubv2df3_mask_round = 1628,
CODE_FOR_sse_vmmulv4sf3 = 1661,
CODE_FOR_sse_vmmulv4sf3_round = 1662,
CODE_FOR_sse_vmmulv4sf3_mask = 1663,
CODE_FOR_sse_vmmulv4sf3_mask_round = 1664,
CODE_FOR_sse_vmdivv4sf3 = 1665,
CODE_FOR_sse_vmdivv4sf3_round = 1666,
CODE_FOR_sse_vmdivv4sf3_mask = 1667,
CODE_FOR_sse_vmdivv4sf3_mask_round = 1668,
CODE_FOR_sse2_vmmulv2df3 = 1669,
CODE_FOR_sse2_vmmulv2df3_round = 1670,
CODE_FOR_sse2_vmmulv2df3_mask = 1671,
CODE_FOR_sse2_vmmulv2df3_mask_round = 1672,
CODE_FOR_sse2_vmdivv2df3 = 1673,
CODE_FOR_sse2_vmdivv2df3_round = 1674,
CODE_FOR_sse2_vmdivv2df3_mask = 1675,
CODE_FOR_sse2_vmdivv2df3_mask_round = 1676,
CODE_FOR_avx512f_divv16sf3 = 1677,
CODE_FOR_avx512f_divv16sf3_round = 1678,
CODE_FOR_avx512f_divv16sf3_mask = 1679,
CODE_FOR_avx512f_divv16sf3_mask_round = 1680,
CODE_FOR_avx_divv8sf3 = 1681,
CODE_FOR_avx_divv8sf3_round = CODE_FOR_nothing,
CODE_FOR_avx_divv8sf3_mask = 1682,
CODE_FOR_avx_divv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_divv4sf3 = 1683,
CODE_FOR_sse_divv4sf3_round = CODE_FOR_nothing,
CODE_FOR_sse_divv4sf3_mask = 1684,
CODE_FOR_sse_divv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_divv8df3 = 1685,
CODE_FOR_avx512f_divv8df3_round = 1686,
CODE_FOR_avx512f_divv8df3_mask = 1687,
CODE_FOR_avx512f_divv8df3_mask_round = 1688,
CODE_FOR_avx_divv4df3 = 1689,
CODE_FOR_avx_divv4df3_round = CODE_FOR_nothing,
CODE_FOR_avx_divv4df3_mask = 1690,
CODE_FOR_avx_divv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse2_divv2df3 = 1691,
CODE_FOR_sse2_divv2df3_round = CODE_FOR_nothing,
CODE_FOR_sse2_divv2df3_mask = 1692,
CODE_FOR_sse2_divv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx_rcpv8sf2 = 1705,
CODE_FOR_sse_rcpv4sf2 = 1706,
CODE_FOR_sse_vmrcpv4sf2 = 1707,
CODE_FOR_rcp14v16sf_mask = 1710,
CODE_FOR_rcp14v8sf_mask = 1712,
CODE_FOR_rcp14v4sf_mask = 1714,
CODE_FOR_rcp14v8df_mask = 1716,
CODE_FOR_rcp14v4df_mask = 1718,
CODE_FOR_rcp14v2df_mask = 1720,
CODE_FOR_srcp14v4sf = 1721,
CODE_FOR_srcp14v2df = 1722,
CODE_FOR_srcp14v4sf_mask = 1723,
CODE_FOR_srcp14v2df_mask = 1724,
CODE_FOR_avx512f_sqrtv16sf2 = 1725,
CODE_FOR_avx512f_sqrtv16sf2_round = 1726,
CODE_FOR_avx512f_sqrtv16sf2_mask = 1727,
CODE_FOR_avx512f_sqrtv16sf2_mask_round = 1728,
CODE_FOR_avx_sqrtv8sf2 = 1729,
CODE_FOR_avx_sqrtv8sf2_round = CODE_FOR_nothing,
CODE_FOR_avx_sqrtv8sf2_mask = 1730,
CODE_FOR_avx_sqrtv8sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_sqrtv4sf2 = 1731,
CODE_FOR_sse_sqrtv4sf2_round = CODE_FOR_nothing,
CODE_FOR_sse_sqrtv4sf2_mask = 1732,
CODE_FOR_sse_sqrtv4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_sqrtv8df2 = 1733,
CODE_FOR_avx512f_sqrtv8df2_round = 1734,
CODE_FOR_avx512f_sqrtv8df2_mask = 1735,
CODE_FOR_avx512f_sqrtv8df2_mask_round = 1736,
CODE_FOR_avx_sqrtv4df2 = 1737,
CODE_FOR_avx_sqrtv4df2_round = CODE_FOR_nothing,
CODE_FOR_avx_sqrtv4df2_mask = 1738,
CODE_FOR_avx_sqrtv4df2_mask_round = CODE_FOR_nothing,
CODE_FOR_sse2_sqrtv2df2 = 1739,
CODE_FOR_sse2_sqrtv2df2_round = CODE_FOR_nothing,
CODE_FOR_sse2_sqrtv2df2_mask = 1740,
CODE_FOR_sse2_sqrtv2df2_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_vmsqrtv4sf2 = 1741,
CODE_FOR_sse_vmsqrtv4sf2_round = 1742,
CODE_FOR_sse_vmsqrtv4sf2_mask = 1743,
CODE_FOR_sse_vmsqrtv4sf2_mask_round = 1744,
CODE_FOR_sse2_vmsqrtv2df2 = 1745,
CODE_FOR_sse2_vmsqrtv2df2_round = 1746,
CODE_FOR_sse2_vmsqrtv2df2_mask = 1747,
CODE_FOR_sse2_vmsqrtv2df2_mask_round = 1748,
CODE_FOR_avx_rsqrtv8sf2 = 1757,
CODE_FOR_sse_rsqrtv4sf2 = 1758,
CODE_FOR_rsqrt14v16sf_mask = 1760,
CODE_FOR_rsqrt14v8sf_mask = 1762,
CODE_FOR_rsqrt14v4sf_mask = 1764,
CODE_FOR_rsqrt14v8df_mask = 1766,
CODE_FOR_rsqrt14v4df_mask = 1768,
CODE_FOR_rsqrt14v2df_mask = 1770,
CODE_FOR_rsqrt14v4sf = 1771,
CODE_FOR_rsqrt14v2df = 1772,
CODE_FOR_rsqrt14_v4sf_mask = 1773,
CODE_FOR_rsqrt14_v2df_mask = 1774,
CODE_FOR_sse_vmrsqrtv4sf2 = 1775,
CODE_FOR_ieee_maxv16sf3 = 1809,
CODE_FOR_ieee_maxv16sf3_round = 1810,
CODE_FOR_ieee_maxv16sf3_mask = 1811,
CODE_FOR_ieee_maxv16sf3_mask_round = 1812,
CODE_FOR_ieee_minv16sf3 = 1813,
CODE_FOR_ieee_minv16sf3_round = 1814,
CODE_FOR_ieee_minv16sf3_mask = 1815,
CODE_FOR_ieee_minv16sf3_mask_round = 1816,
CODE_FOR_ieee_maxv8sf3 = 1817,
CODE_FOR_ieee_maxv8sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv8sf3_mask = 1818,
CODE_FOR_ieee_maxv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv8sf3 = 1819,
CODE_FOR_ieee_minv8sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv8sf3_mask = 1820,
CODE_FOR_ieee_minv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv4sf3 = 1821,
CODE_FOR_ieee_maxv4sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv4sf3_mask = 1822,
CODE_FOR_ieee_maxv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4sf3 = 1823,
CODE_FOR_ieee_minv4sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4sf3_mask = 1824,
CODE_FOR_ieee_minv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv8df3 = 1825,
CODE_FOR_ieee_maxv8df3_round = 1826,
CODE_FOR_ieee_maxv8df3_mask = 1827,
CODE_FOR_ieee_maxv8df3_mask_round = 1828,
CODE_FOR_ieee_minv8df3 = 1829,
CODE_FOR_ieee_minv8df3_round = 1830,
CODE_FOR_ieee_minv8df3_mask = 1831,
CODE_FOR_ieee_minv8df3_mask_round = 1832,
CODE_FOR_ieee_maxv4df3 = 1833,
CODE_FOR_ieee_maxv4df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv4df3_mask = 1834,
CODE_FOR_ieee_maxv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4df3 = 1835,
CODE_FOR_ieee_minv4df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4df3_mask = 1836,
CODE_FOR_ieee_minv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv2df3 = 1837,
CODE_FOR_ieee_maxv2df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv2df3_mask = 1838,
CODE_FOR_ieee_maxv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv2df3 = 1839,
CODE_FOR_ieee_minv2df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv2df3_mask = 1840,
CODE_FOR_ieee_minv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_vmsmaxv4sf3 = 1845,
CODE_FOR_sse_vmsmaxv4sf3_mask = 1846,
CODE_FOR_sse_vmsmaxv4sf3_round = 1847,
CODE_FOR_sse_vmsmaxv4sf3_mask_round = 1848,
CODE_FOR_sse_vmsminv4sf3 = 1849,
CODE_FOR_sse_vmsminv4sf3_mask = 1850,
CODE_FOR_sse_vmsminv4sf3_round = 1851,
CODE_FOR_sse_vmsminv4sf3_mask_round = 1852,
CODE_FOR_sse2_vmsmaxv2df3 = 1853,
CODE_FOR_sse2_vmsmaxv2df3_mask = 1854,
CODE_FOR_sse2_vmsmaxv2df3_round = 1855,
CODE_FOR_sse2_vmsmaxv2df3_mask_round = 1856,
CODE_FOR_sse2_vmsminv2df3 = 1857,
CODE_FOR_sse2_vmsminv2df3_mask = 1858,
CODE_FOR_sse2_vmsminv2df3_round = 1859,
CODE_FOR_sse2_vmsminv2df3_mask_round = 1860,
CODE_FOR_avx_addsubv4df3 = 1861,
CODE_FOR_sse3_addsubv2df3 = 1862,
CODE_FOR_avx_addsubv8sf3 = 1863,
CODE_FOR_sse3_addsubv4sf3 = 1864,
CODE_FOR_avx_haddv4df3 = 1865,
CODE_FOR_avx_hsubv4df3 = 1866,
CODE_FOR_sse3_hsubv2df3 = 1868,
CODE_FOR_avx_haddv8sf3 = 1871,
CODE_FOR_avx_hsubv8sf3 = 1872,
CODE_FOR_sse3_haddv4sf3 = 1873,
CODE_FOR_sse3_hsubv4sf3 = 1874,
CODE_FOR_reducepv16sf_mask = 1876,
CODE_FOR_reducepv8sf_mask = 1878,
CODE_FOR_reducepv4sf_mask = 1880,
CODE_FOR_reducepv8df_mask = 1882,
CODE_FOR_reducepv4df_mask = 1884,
CODE_FOR_reducepv2df_mask = 1886,
CODE_FOR_reducesv4sf = 1887,
CODE_FOR_reducesv4sf_mask = 1888,
CODE_FOR_reducesv2df = 1889,
CODE_FOR_reducesv2df_mask = 1890,
CODE_FOR_avx_cmpv8sf3 = 1891,
CODE_FOR_avx_cmpv4sf3 = 1892,
CODE_FOR_avx_cmpv4df3 = 1893,
CODE_FOR_avx_cmpv2df3 = 1894,
CODE_FOR_avx_vmcmpv4sf3 = 1895,
CODE_FOR_avx_vmcmpv2df3 = 1896,
CODE_FOR_avx_maskcmpv8sf3 = 1901,
CODE_FOR_sse_maskcmpv4sf3 = 1902,
CODE_FOR_avx_maskcmpv4df3 = 1903,
CODE_FOR_sse2_maskcmpv2df3 = 1904,
CODE_FOR_sse_vmmaskcmpv4sf3 = 1905,
CODE_FOR_sse2_vmmaskcmpv2df3 = 1906,
CODE_FOR_avx512f_cmpv16si3 = 1907,
CODE_FOR_avx512f_cmpv16si3_round = 1908,
CODE_FOR_avx512f_cmpv16si3_mask = 1909,
CODE_FOR_avx512f_cmpv16si3_mask_round = 1910,
CODE_FOR_avx512vl_cmpv8si3 = 1911,
CODE_FOR_avx512vl_cmpv8si3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv8si3_mask = 1912,
CODE_FOR_avx512vl_cmpv8si3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4si3 = 1913,
CODE_FOR_avx512vl_cmpv4si3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4si3_mask = 1914,
CODE_FOR_avx512vl_cmpv4si3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_cmpv8di3 = 1915,
CODE_FOR_avx512f_cmpv8di3_round = 1916,
CODE_FOR_avx512f_cmpv8di3_mask = 1917,
CODE_FOR_avx512f_cmpv8di3_mask_round = 1918,
CODE_FOR_avx512vl_cmpv4di3 = 1919,
CODE_FOR_avx512vl_cmpv4di3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4di3_mask = 1920,
CODE_FOR_avx512vl_cmpv4di3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2di3 = 1921,
CODE_FOR_avx512vl_cmpv2di3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2di3_mask = 1922,
CODE_FOR_avx512vl_cmpv2di3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_cmpv16sf3 = 1923,
CODE_FOR_avx512f_cmpv16sf3_round = 1924,
CODE_FOR_avx512f_cmpv16sf3_mask = 1925,
CODE_FOR_avx512f_cmpv16sf3_mask_round = 1926,
CODE_FOR_avx512vl_cmpv8sf3 = 1927,
CODE_FOR_avx512vl_cmpv8sf3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv8sf3_mask = 1928,
CODE_FOR_avx512vl_cmpv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4sf3 = 1929,
CODE_FOR_avx512vl_cmpv4sf3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4sf3_mask = 1930,
CODE_FOR_avx512vl_cmpv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_cmpv8df3 = 1931,
CODE_FOR_avx512f_cmpv8df3_round = 1932,
CODE_FOR_avx512f_cmpv8df3_mask = 1933,
CODE_FOR_avx512f_cmpv8df3_mask_round = 1934,
CODE_FOR_avx512vl_cmpv4df3 = 1935,
CODE_FOR_avx512vl_cmpv4df3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4df3_mask = 1936,
CODE_FOR_avx512vl_cmpv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2df3 = 1937,
CODE_FOR_avx512vl_cmpv2df3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2df3_mask = 1938,
CODE_FOR_avx512vl_cmpv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512bw_cmpv64qi3 = 1939,
CODE_FOR_avx512bw_cmpv64qi3_mask = 1940,
CODE_FOR_avx512vl_cmpv16qi3 = 1941,
CODE_FOR_avx512vl_cmpv16qi3_mask = 1942,
CODE_FOR_avx512vl_cmpv32qi3 = 1943,
CODE_FOR_avx512vl_cmpv32qi3_mask = 1944,
CODE_FOR_avx512bw_cmpv32hi3 = 1945,
CODE_FOR_avx512bw_cmpv32hi3_mask = 1946,
CODE_FOR_avx512vl_cmpv16hi3 = 1947,
CODE_FOR_avx512vl_cmpv16hi3_mask = 1948,
CODE_FOR_avx512vl_cmpv8hi3 = 1949,
CODE_FOR_avx512vl_cmpv8hi3_mask = 1950,
CODE_FOR_avx512bw_ucmpv64qi3 = 1951,
CODE_FOR_avx512bw_ucmpv64qi3_mask = 1952,
CODE_FOR_avx512vl_ucmpv16qi3 = 1953,
CODE_FOR_avx512vl_ucmpv16qi3_mask = 1954,
CODE_FOR_avx512vl_ucmpv32qi3 = 1955,
CODE_FOR_avx512vl_ucmpv32qi3_mask = 1956,
CODE_FOR_avx512bw_ucmpv32hi3 = 1957,
CODE_FOR_avx512bw_ucmpv32hi3_mask = 1958,
CODE_FOR_avx512vl_ucmpv16hi3 = 1959,
CODE_FOR_avx512vl_ucmpv16hi3_mask = 1960,
CODE_FOR_avx512vl_ucmpv8hi3 = 1961,
CODE_FOR_avx512vl_ucmpv8hi3_mask = 1962,
CODE_FOR_avx512f_ucmpv16si3 = 1963,
CODE_FOR_avx512f_ucmpv16si3_mask = 1964,
CODE_FOR_avx512vl_ucmpv8si3 = 1965,
CODE_FOR_avx512vl_ucmpv8si3_mask = 1966,
CODE_FOR_avx512vl_ucmpv4si3 = 1967,
CODE_FOR_avx512vl_ucmpv4si3_mask = 1968,
CODE_FOR_avx512f_ucmpv8di3 = 1969,
CODE_FOR_avx512f_ucmpv8di3_mask = 1970,
CODE_FOR_avx512vl_ucmpv4di3 = 1971,
CODE_FOR_avx512vl_ucmpv4di3_mask = 1972,
CODE_FOR_avx512vl_ucmpv2di3 = 1973,
CODE_FOR_avx512vl_ucmpv2di3_mask = 1974,
CODE_FOR_avx512f_vmcmpv4sf3 = 1975,
CODE_FOR_avx512f_vmcmpv4sf3_round = 1976,
CODE_FOR_avx512f_vmcmpv2df3 = 1977,
CODE_FOR_avx512f_vmcmpv2df3_round = 1978,
CODE_FOR_avx512f_vmcmpv4sf3_mask = 1979,
CODE_FOR_avx512f_vmcmpv4sf3_mask_round = 1980,
CODE_FOR_avx512f_vmcmpv2df3_mask = 1981,
CODE_FOR_avx512f_vmcmpv2df3_mask_round = 1982,
CODE_FOR_sse_comi = 1983,
CODE_FOR_sse_comi_round = 1984,
CODE_FOR_sse_ucomi = 1985,
CODE_FOR_sse_ucomi_round = 1986,
CODE_FOR_sse2_comi = 1987,
CODE_FOR_sse2_comi_round = 1988,
CODE_FOR_sse2_ucomi = 1989,
CODE_FOR_sse2_ucomi_round = 1990,
CODE_FOR_avx_andnotv8sf3 = 1991,
CODE_FOR_avx_andnotv8sf3_mask = 1992,
CODE_FOR_sse_andnotv4sf3 = 1993,
CODE_FOR_sse_andnotv4sf3_mask = 1994,
CODE_FOR_avx_andnotv4df3 = 1995,
CODE_FOR_avx_andnotv4df3_mask = 1996,
CODE_FOR_sse2_andnotv2df3 = 1997,
CODE_FOR_sse2_andnotv2df3_mask = 1998,
CODE_FOR_avx512f_andnotv16sf3 = 1999,
CODE_FOR_avx512f_andnotv16sf3_mask = 2000,
CODE_FOR_avx512f_andnotv8df3 = 2001,
CODE_FOR_avx512f_andnotv8df3_mask = 2002,
CODE_FOR_fma_fmadd_v16sf_maskz_1 = 2059,
CODE_FOR_fma_fmadd_v16sf_maskz_1_round = 2061,
CODE_FOR_fma_fmadd_v8sf_maskz_1 = 2063,
CODE_FOR_fma_fmadd_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmadd_v4sf_maskz_1 = 2065,
CODE_FOR_fma_fmadd_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmadd_v8df_maskz_1 = 2068,
CODE_FOR_fma_fmadd_v8df_maskz_1_round = 2070,
CODE_FOR_fma_fmadd_v4df_maskz_1 = 2072,
CODE_FOR_fma_fmadd_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmadd_v2df_maskz_1 = 2074,
CODE_FOR_fma_fmadd_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmadd_v16sf_mask = 2111,
CODE_FOR_avx512f_fmadd_v16sf_mask_round = 2112,
CODE_FOR_avx512vl_fmadd_v8sf_mask = 2113,
CODE_FOR_avx512vl_fmadd_v8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmadd_v4sf_mask = 2114,
CODE_FOR_avx512vl_fmadd_v4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmadd_v8df_mask = 2115,
CODE_FOR_avx512f_fmadd_v8df_mask_round = 2116,
CODE_FOR_avx512vl_fmadd_v4df_mask = 2117,
CODE_FOR_avx512vl_fmadd_v4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmadd_v2df_mask = 2118,
CODE_FOR_avx512vl_fmadd_v2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmadd_v16sf_mask3 = 2119,
CODE_FOR_avx512f_fmadd_v16sf_mask3_round = 2120,
CODE_FOR_avx512vl_fmadd_v8sf_mask3 = 2121,
CODE_FOR_avx512vl_fmadd_v8sf_mask3_round = 2122,
CODE_FOR_avx512vl_fmadd_v4sf_mask3 = 2123,
CODE_FOR_avx512vl_fmadd_v4sf_mask3_round = 2124,
CODE_FOR_avx512f_fmadd_v8df_mask3 = 2125,
CODE_FOR_avx512f_fmadd_v8df_mask3_round = 2126,
CODE_FOR_avx512vl_fmadd_v4df_mask3 = 2127,
CODE_FOR_avx512vl_fmadd_v4df_mask3_round = 2128,
CODE_FOR_avx512vl_fmadd_v2df_mask3 = 2129,
CODE_FOR_avx512vl_fmadd_v2df_mask3_round = 2130,
CODE_FOR_fma_fmsub_v16sf_maskz_1 = 2139,
CODE_FOR_fma_fmsub_v16sf_maskz_1_round = 2141,
CODE_FOR_fma_fmsub_v8sf_maskz_1 = 2143,
CODE_FOR_fma_fmsub_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsub_v4sf_maskz_1 = 2145,
CODE_FOR_fma_fmsub_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsub_v8df_maskz_1 = 2148,
CODE_FOR_fma_fmsub_v8df_maskz_1_round = 2150,
CODE_FOR_fma_fmsub_v4df_maskz_1 = 2152,
CODE_FOR_fma_fmsub_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsub_v2df_maskz_1 = 2154,
CODE_FOR_fma_fmsub_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmsub_v16sf_mask = 2191,
CODE_FOR_avx512f_fmsub_v16sf_mask_round = 2192,
CODE_FOR_avx512vl_fmsub_v8sf_mask = 2193,
CODE_FOR_avx512vl_fmsub_v8sf_mask_round = 2194,
CODE_FOR_avx512vl_fmsub_v4sf_mask = 2195,
CODE_FOR_avx512vl_fmsub_v4sf_mask_round = 2196,
CODE_FOR_avx512f_fmsub_v8df_mask = 2197,
CODE_FOR_avx512f_fmsub_v8df_mask_round = 2198,
CODE_FOR_avx512vl_fmsub_v4df_mask = 2199,
CODE_FOR_avx512vl_fmsub_v4df_mask_round = 2200,
CODE_FOR_avx512vl_fmsub_v2df_mask = 2201,
CODE_FOR_avx512vl_fmsub_v2df_mask_round = 2202,
CODE_FOR_avx512f_fmsub_v16sf_mask3 = 2203,
CODE_FOR_avx512f_fmsub_v16sf_mask3_round = 2204,
CODE_FOR_avx512vl_fmsub_v8sf_mask3 = 2205,
CODE_FOR_avx512vl_fmsub_v8sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmsub_v4sf_mask3 = 2206,
CODE_FOR_avx512vl_fmsub_v4sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmsub_v8df_mask3 = 2207,
CODE_FOR_avx512f_fmsub_v8df_mask3_round = 2208,
CODE_FOR_avx512vl_fmsub_v4df_mask3 = 2209,
CODE_FOR_avx512vl_fmsub_v4df_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmsub_v2df_mask3 = 2210,
CODE_FOR_avx512vl_fmsub_v2df_mask3_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v16sf_maskz_1 = 2219,
CODE_FOR_fma_fnmadd_v16sf_maskz_1_round = 2221,
CODE_FOR_fma_fnmadd_v8sf_maskz_1 = 2223,
CODE_FOR_fma_fnmadd_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v4sf_maskz_1 = 2225,
CODE_FOR_fma_fnmadd_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v8df_maskz_1 = 2228,
CODE_FOR_fma_fnmadd_v8df_maskz_1_round = 2230,
CODE_FOR_fma_fnmadd_v4df_maskz_1 = 2232,
CODE_FOR_fma_fnmadd_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v2df_maskz_1 = 2234,
CODE_FOR_fma_fnmadd_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v16sf_mask = 2271,
CODE_FOR_avx512f_fnmadd_v16sf_mask_round = 2272,
CODE_FOR_avx512vl_fnmadd_v8sf_mask = 2273,
CODE_FOR_avx512vl_fnmadd_v8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v4sf_mask = 2274,
CODE_FOR_avx512vl_fnmadd_v4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v8df_mask = 2275,
CODE_FOR_avx512f_fnmadd_v8df_mask_round = 2276,
CODE_FOR_avx512vl_fnmadd_v4df_mask = 2277,
CODE_FOR_avx512vl_fnmadd_v4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v2df_mask = 2278,
CODE_FOR_avx512vl_fnmadd_v2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v16sf_mask3 = 2279,
CODE_FOR_avx512f_fnmadd_v16sf_mask3_round = 2280,
CODE_FOR_avx512vl_fnmadd_v8sf_mask3 = 2281,
CODE_FOR_avx512vl_fnmadd_v8sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v4sf_mask3 = 2282,
CODE_FOR_avx512vl_fnmadd_v4sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v8df_mask3 = 2283,
CODE_FOR_avx512f_fnmadd_v8df_mask3_round = 2284,
CODE_FOR_avx512vl_fnmadd_v4df_mask3 = 2285,
CODE_FOR_avx512vl_fnmadd_v4df_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v2df_mask3 = 2286,
CODE_FOR_avx512vl_fnmadd_v2df_mask3_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v16sf_maskz_1 = 2309,
CODE_FOR_fma_fnmsub_v16sf_maskz_1_round = 2311,
CODE_FOR_fma_fnmsub_v8sf_maskz_1 = 2313,
CODE_FOR_fma_fnmsub_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v4sf_maskz_1 = 2315,
CODE_FOR_fma_fnmsub_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v8df_maskz_1 = 2318,
CODE_FOR_fma_fnmsub_v8df_maskz_1_round = 2320,
CODE_FOR_fma_fnmsub_v4df_maskz_1 = 2322,
CODE_FOR_fma_fnmsub_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v2df_maskz_1 = 2324,
CODE_FOR_fma_fnmsub_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmsub_v16sf_mask = 2361,
CODE_FOR_avx512f_fnmsub_v16sf_mask_round = 2362,
CODE_FOR_avx512vl_fnmsub_v8sf_mask = 2363,
CODE_FOR_avx512vl_fnmsub_v8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmsub_v4sf_mask = 2364,
CODE_FOR_avx512vl_fnmsub_v4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmsub_v8df_mask = 2365,
CODE_FOR_avx512f_fnmsub_v8df_mask_round = 2366,
CODE_FOR_avx512vl_fnmsub_v4df_mask = 2367,
CODE_FOR_avx512vl_fnmsub_v4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmsub_v2df_mask = 2368,
CODE_FOR_avx512vl_fnmsub_v2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmsub_v16sf_mask3 = 2369,
CODE_FOR_avx512f_fnmsub_v16sf_mask3_round = 2370,
CODE_FOR_avx512vl_fnmsub_v8sf_mask3 = 2371,
CODE_FOR_avx512vl_fnmsub_v8sf_mask3_round = 2372,
CODE_FOR_avx512vl_fnmsub_v4sf_mask3 = 2373,
CODE_FOR_avx512vl_fnmsub_v4sf_mask3_round = 2374,
CODE_FOR_avx512f_fnmsub_v8df_mask3 = 2375,
CODE_FOR_avx512f_fnmsub_v8df_mask3_round = 2376,
CODE_FOR_avx512vl_fnmsub_v4df_mask3 = 2377,
CODE_FOR_avx512vl_fnmsub_v4df_mask3_round = 2378,
CODE_FOR_avx512vl_fnmsub_v2df_mask3 = 2379,
CODE_FOR_avx512vl_fnmsub_v2df_mask3_round = 2380,
CODE_FOR_fma_fmaddsub_v16sf_maskz_1 = 2387,
CODE_FOR_fma_fmaddsub_v16sf_maskz_1_round = 2389,
CODE_FOR_fma_fmaddsub_v8sf_maskz_1 = 2391,
CODE_FOR_fma_fmaddsub_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmaddsub_v4sf_maskz_1 = 2393,
CODE_FOR_fma_fmaddsub_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmaddsub_v8df_maskz_1 = 2396,
CODE_FOR_fma_fmaddsub_v8df_maskz_1_round = 2398,
CODE_FOR_fma_fmaddsub_v4df_maskz_1 = 2400,
CODE_FOR_fma_fmaddsub_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmaddsub_v2df_maskz_1 = 2402,
CODE_FOR_fma_fmaddsub_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmaddsub_v16sf_mask = 2403,
CODE_FOR_avx512f_fmaddsub_v16sf_mask_round = 2404,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask = 2405,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask_round = 2406,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask = 2407,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask_round = 2408,
CODE_FOR_avx512f_fmaddsub_v8df_mask = 2409,
CODE_FOR_avx512f_fmaddsub_v8df_mask_round = 2410,
CODE_FOR_avx512vl_fmaddsub_v4df_mask = 2411,
CODE_FOR_avx512vl_fmaddsub_v4df_mask_round = 2412,
CODE_FOR_avx512vl_fmaddsub_v2df_mask = 2413,
CODE_FOR_avx512vl_fmaddsub_v2df_mask_round = 2414,
CODE_FOR_avx512f_fmaddsub_v16sf_mask3 = 2415,
CODE_FOR_avx512f_fmaddsub_v16sf_mask3_round = 2416,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask3 = 2417,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask3_round = 2418,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask3 = 2419,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask3_round = 2420,
CODE_FOR_avx512f_fmaddsub_v8df_mask3 = 2421,
CODE_FOR_avx512f_fmaddsub_v8df_mask3_round = 2422,
CODE_FOR_avx512vl_fmaddsub_v4df_mask3 = 2423,
CODE_FOR_avx512vl_fmaddsub_v4df_mask3_round = 2424,
CODE_FOR_avx512vl_fmaddsub_v2df_mask3 = 2425,
CODE_FOR_avx512vl_fmaddsub_v2df_mask3_round = 2426,
CODE_FOR_fma_fmsubadd_v16sf_maskz_1 = 2433,
CODE_FOR_fma_fmsubadd_v16sf_maskz_1_round = 2435,
CODE_FOR_fma_fmsubadd_v8sf_maskz_1 = 2437,
CODE_FOR_fma_fmsubadd_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsubadd_v4sf_maskz_1 = 2439,
CODE_FOR_fma_fmsubadd_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsubadd_v8df_maskz_1 = 2442,
CODE_FOR_fma_fmsubadd_v8df_maskz_1_round = 2444,
CODE_FOR_fma_fmsubadd_v4df_maskz_1 = 2446,
CODE_FOR_fma_fmsubadd_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsubadd_v2df_maskz_1 = 2448,
CODE_FOR_fma_fmsubadd_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmsubadd_v16sf_mask = 2449,
CODE_FOR_avx512f_fmsubadd_v16sf_mask_round = 2450,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask = 2451,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask_round = 2452,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask = 2453,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask_round = 2454,
CODE_FOR_avx512f_fmsubadd_v8df_mask = 2455,
CODE_FOR_avx512f_fmsubadd_v8df_mask_round = 2456,
CODE_FOR_avx512vl_fmsubadd_v4df_mask = 2457,
CODE_FOR_avx512vl_fmsubadd_v4df_mask_round = 2458,
CODE_FOR_avx512vl_fmsubadd_v2df_mask = 2459,
CODE_FOR_avx512vl_fmsubadd_v2df_mask_round = 2460,
CODE_FOR_avx512f_fmsubadd_v16sf_mask3 = 2461,
CODE_FOR_avx512f_fmsubadd_v16sf_mask3_round = 2462,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask3 = 2463,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask3_round = 2464,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask3 = 2465,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask3_round = 2466,
CODE_FOR_avx512f_fmsubadd_v8df_mask3 = 2467,
CODE_FOR_avx512f_fmsubadd_v8df_mask3_round = 2468,
CODE_FOR_avx512vl_fmsubadd_v4df_mask3 = 2469,
CODE_FOR_avx512vl_fmsubadd_v4df_mask3_round = 2470,
CODE_FOR_avx512vl_fmsubadd_v2df_mask3 = 2471,
CODE_FOR_avx512vl_fmsubadd_v2df_mask3_round = 2472,
CODE_FOR_avx512f_vmfmadd_v4sf_mask = 2489,
CODE_FOR_avx512f_vmfmadd_v4sf_mask_round = 2490,
CODE_FOR_avx512f_vmfmadd_v2df_mask = 2491,
CODE_FOR_avx512f_vmfmadd_v2df_mask_round = 2492,
CODE_FOR_avx512f_vmfmadd_v4sf_mask3 = 2493,
CODE_FOR_avx512f_vmfmadd_v4sf_mask3_round = 2494,
CODE_FOR_avx512f_vmfmadd_v2df_mask3 = 2495,
CODE_FOR_avx512f_vmfmadd_v2df_mask3_round = 2496,
CODE_FOR_avx512f_vmfmadd_v4sf_maskz_1 = 2497,
CODE_FOR_avx512f_vmfmadd_v4sf_maskz_1_round = 2498,
CODE_FOR_avx512f_vmfmadd_v2df_maskz_1 = 2499,
CODE_FOR_avx512f_vmfmadd_v2df_maskz_1_round = 2500,
CODE_FOR_avx512f_vmfmsub_v4sf_mask3 = 2505,
CODE_FOR_avx512f_vmfmsub_v4sf_mask3_round = 2506,
CODE_FOR_avx512f_vmfmsub_v2df_mask3 = 2507,
CODE_FOR_avx512f_vmfmsub_v2df_mask3_round = 2508,
CODE_FOR_sse_cvtpi2ps = 2545,
CODE_FOR_sse_cvtps2pi = 2546,
CODE_FOR_sse_cvttps2pi = 2547,
CODE_FOR_sse_cvtsi2ss = 2548,
CODE_FOR_sse_cvtsi2ss_round = 2549,
CODE_FOR_sse_cvtsi2ssq = 2550,
CODE_FOR_sse_cvtsi2ssq_round = 2551,
CODE_FOR_sse_cvtss2si = 2552,
CODE_FOR_sse_cvtss2si_round = 2553,
CODE_FOR_sse_cvtss2siq = 2554,
CODE_FOR_sse_cvtss2siq_round = 2555,
CODE_FOR_sse_cvtss2si_2 = 2556,
CODE_FOR_sse_cvtss2siq_2 = 2557,
CODE_FOR_sse_cvttss2si = 2558,
CODE_FOR_sse_cvttss2si_round = 2559,
CODE_FOR_sse_cvttss2siq = 2560,
CODE_FOR_sse_cvttss2siq_round = 2561,
CODE_FOR_cvtusi2ss32 = 2562,
CODE_FOR_cvtusi2ss32_round = 2563,
CODE_FOR_cvtusi2sd32 = 2564,
CODE_FOR_cvtusi2sd32_round = CODE_FOR_nothing,
CODE_FOR_cvtusi2ss64 = 2565,
CODE_FOR_cvtusi2ss64_round = 2566,
CODE_FOR_cvtusi2sd64 = 2567,
CODE_FOR_cvtusi2sd64_round = 2568,
CODE_FOR_floatv16siv16sf2 = 2569,
CODE_FOR_floatv16siv16sf2_round = 2570,
CODE_FOR_floatv16siv16sf2_mask = 2571,
CODE_FOR_floatv16siv16sf2_mask_round = 2572,
CODE_FOR_floatv8siv8sf2 = 2573,
CODE_FOR_floatv8siv8sf2_round = CODE_FOR_nothing,
CODE_FOR_floatv8siv8sf2_mask = 2574,
CODE_FOR_floatv8siv8sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_floatv4siv4sf2 = 2575,
CODE_FOR_floatv4siv4sf2_round = CODE_FOR_nothing,
CODE_FOR_floatv4siv4sf2_mask = 2576,
CODE_FOR_floatv4siv4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufloatv16siv16sf2 = 2577,
CODE_FOR_ufloatv16siv16sf2_round = 2578,
CODE_FOR_ufloatv16siv16sf2_mask = 2579,
CODE_FOR_ufloatv16siv16sf2_mask_round = 2580,
CODE_FOR_ufloatv8siv8sf2 = 2581,
CODE_FOR_ufloatv8siv8sf2_round = 2582,
CODE_FOR_ufloatv8siv8sf2_mask = 2583,
CODE_FOR_ufloatv8siv8sf2_mask_round = 2584,
CODE_FOR_ufloatv4siv4sf2 = 2585,
CODE_FOR_ufloatv4siv4sf2_round = 2586,
CODE_FOR_ufloatv4siv4sf2_mask = 2587,
CODE_FOR_ufloatv4siv4sf2_mask_round = 2588,
CODE_FOR_avx_fix_notruncv8sfv8si = 2589,
CODE_FOR_avx_fix_notruncv8sfv8si_mask = 2590,
CODE_FOR_sse2_fix_notruncv4sfv4si = 2591,
CODE_FOR_sse2_fix_notruncv4sfv4si_mask = 2592,
CODE_FOR_avx512f_fix_notruncv16sfv16si = 2593,
CODE_FOR_avx512f_fix_notruncv16sfv16si_round = 2594,
CODE_FOR_avx512f_fix_notruncv16sfv16si_mask = 2595,
CODE_FOR_avx512f_fix_notruncv16sfv16si_mask_round = 2596,
CODE_FOR_avx512f_ufix_notruncv16sfv16si_mask = 2599,
CODE_FOR_avx512f_ufix_notruncv16sfv16si_mask_round = 2600,
CODE_FOR_avx512vl_ufix_notruncv8sfv8si_mask = 2603,
CODE_FOR_avx512vl_ufix_notruncv8sfv8si_mask_round = 2604,
CODE_FOR_avx512vl_ufix_notruncv4sfv4si_mask = 2607,
CODE_FOR_avx512vl_ufix_notruncv4sfv4si_mask_round = 2608,
CODE_FOR_avx512dq_cvtps2qqv8di_mask = 2611,
CODE_FOR_avx512dq_cvtps2qqv8di_mask_round = 2612,
CODE_FOR_avx512dq_cvtps2qqv4di_mask = 2614,
CODE_FOR_avx512dq_cvtps2qqv4di_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_cvtps2qqv2di_mask = 2616,
CODE_FOR_avx512dq_cvtps2uqqv8di_mask = 2619,
CODE_FOR_avx512dq_cvtps2uqqv8di_mask_round = 2620,
CODE_FOR_avx512dq_cvtps2uqqv4di_mask = 2622,
CODE_FOR_avx512dq_cvtps2uqqv4di_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_cvtps2uqqv2di_mask = 2624,
CODE_FOR_fix_truncv16sfv16si2 = 2625,
CODE_FOR_fix_truncv16sfv16si2_round = 2626,
CODE_FOR_fix_truncv16sfv16si2_mask = 2627,
CODE_FOR_fix_truncv16sfv16si2_mask_round = 2628,
CODE_FOR_ufix_truncv16sfv16si2 = 2629,
CODE_FOR_ufix_truncv16sfv16si2_round = 2630,
CODE_FOR_ufix_truncv16sfv16si2_mask = 2631,
CODE_FOR_ufix_truncv16sfv16si2_mask_round = 2632,
CODE_FOR_fix_truncv8sfv8si2 = 2633,
CODE_FOR_fix_truncv8sfv8si2_mask = 2634,
CODE_FOR_fix_truncv4sfv4si2 = 2635,
CODE_FOR_fix_truncv4sfv4si2_mask = 2636,
CODE_FOR_sse2_cvtpi2pd = 2637,
CODE_FOR_floatunsv2siv2df2 = 2638,
CODE_FOR_sse2_cvtpd2pi = 2639,
CODE_FOR_sse2_cvttpd2pi = 2640,
CODE_FOR_fixuns_truncv2dfv2si2 = 2641,
CODE_FOR_sse2_cvtsi2sd = 2642,
CODE_FOR_sse2_cvtsi2sdq = 2643,
CODE_FOR_sse2_cvtsi2sdq_round = 2644,
CODE_FOR_avx512f_vcvtss2usi = 2645,
CODE_FOR_avx512f_vcvtss2usi_round = 2646,
CODE_FOR_avx512f_vcvtss2usiq = 2647,
CODE_FOR_avx512f_vcvtss2usiq_round = 2648,
CODE_FOR_avx512f_vcvttss2usi = 2649,
CODE_FOR_avx512f_vcvttss2usi_round = 2650,
CODE_FOR_avx512f_vcvttss2usiq = 2651,
CODE_FOR_avx512f_vcvttss2usiq_round = 2652,
CODE_FOR_avx512f_vcvtsd2usi = 2653,
CODE_FOR_avx512f_vcvtsd2usi_round = 2654,
CODE_FOR_avx512f_vcvtsd2usiq = 2655,
CODE_FOR_avx512f_vcvtsd2usiq_round = 2656,
CODE_FOR_avx512f_vcvttsd2usi = 2657,
CODE_FOR_avx512f_vcvttsd2usi_round = 2658,
CODE_FOR_avx512f_vcvttsd2usiq = 2659,
CODE_FOR_avx512f_vcvttsd2usiq_round = 2660,
CODE_FOR_sse2_cvtsd2si = 2661,
CODE_FOR_sse2_cvtsd2si_round = 2662,
CODE_FOR_sse2_cvtsd2siq = 2663,
CODE_FOR_sse2_cvtsd2siq_round = 2664,
CODE_FOR_sse2_cvtsd2si_2 = 2665,
CODE_FOR_sse2_cvtsd2siq_2 = 2666,
CODE_FOR_sse2_cvttsd2si = 2667,
CODE_FOR_sse2_cvttsd2si_round = 2668,
CODE_FOR_sse2_cvttsd2siq = 2669,
CODE_FOR_sse2_cvttsd2siq_round = 2670,
CODE_FOR_floatv8siv8df2 = 2671,
CODE_FOR_floatv8siv8df2_mask = 2672,
CODE_FOR_floatv4siv4df2 = 2673,
CODE_FOR_floatv4siv4df2_mask = 2674,
CODE_FOR_floatv8div8df2 = 2675,
CODE_FOR_floatv8div8df2_round = 2676,
CODE_FOR_floatv8div8df2_mask = 2677,
CODE_FOR_floatv8div8df2_mask_round = 2678,
CODE_FOR_floatunsv8div8df2 = 2679,
CODE_FOR_floatunsv8div8df2_round = 2680,
CODE_FOR_floatunsv8div8df2_mask = 2681,
CODE_FOR_floatunsv8div8df2_mask_round = 2682,
CODE_FOR_floatv4div4df2 = 2683,
CODE_FOR_floatv4div4df2_round = 2684,
CODE_FOR_floatv4div4df2_mask = 2685,
CODE_FOR_floatv4div4df2_mask_round = 2686,
CODE_FOR_floatunsv4div4df2 = 2687,
CODE_FOR_floatunsv4div4df2_round = 2688,
CODE_FOR_floatunsv4div4df2_mask = 2689,
CODE_FOR_floatunsv4div4df2_mask_round = 2690,
CODE_FOR_floatv2div2df2 = 2691,
CODE_FOR_floatv2div2df2_round = 2692,
CODE_FOR_floatv2div2df2_mask = 2693,
CODE_FOR_floatv2div2df2_mask_round = 2694,
CODE_FOR_floatunsv2div2df2 = 2695,
CODE_FOR_floatunsv2div2df2_round = 2696,
CODE_FOR_floatunsv2div2df2_mask = 2697,
CODE_FOR_floatunsv2div2df2_mask_round = 2698,
CODE_FOR_floatv8div8sf2 = 2699,
CODE_FOR_floatv8div8sf2_round = 2700,
CODE_FOR_floatv8div8sf2_mask = 2701,
CODE_FOR_floatv8div8sf2_mask_round = 2702,
CODE_FOR_floatunsv8div8sf2 = 2703,
CODE_FOR_floatunsv8div8sf2_round = 2704,
CODE_FOR_floatunsv8div8sf2_mask = 2705,
CODE_FOR_floatunsv8div8sf2_mask_round = 2706,
CODE_FOR_floatv4div4sf2 = 2707,
CODE_FOR_floatv4div4sf2_round = CODE_FOR_nothing,
CODE_FOR_floatv4div4sf2_mask = 2708,
CODE_FOR_floatv4div4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_floatunsv4div4sf2 = 2709,
CODE_FOR_floatunsv4div4sf2_round = CODE_FOR_nothing,
CODE_FOR_floatunsv4div4sf2_mask = 2710,
CODE_FOR_floatunsv4div4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufloatv8siv8df2 = 2717,
CODE_FOR_ufloatv8siv8df2_mask = 2718,
CODE_FOR_ufloatv4siv4df2 = 2719,
CODE_FOR_ufloatv4siv4df2_mask = 2720,
CODE_FOR_ufloatv2siv2df2 = 2721,
CODE_FOR_ufloatv2siv2df2_mask = 2722,
CODE_FOR_avx512f_cvtdq2pd512_2 = 2723,
CODE_FOR_avx_cvtdq2pd256_2 = 2724,
CODE_FOR_sse2_cvtdq2pd = 2725,
CODE_FOR_sse2_cvtdq2pd_mask = 2726,
CODE_FOR_avx512f_cvtpd2dq512 = 2727,
CODE_FOR_avx512f_cvtpd2dq512_round = 2728,
CODE_FOR_avx512f_cvtpd2dq512_mask = 2729,
CODE_FOR_avx512f_cvtpd2dq512_mask_round = 2730,
CODE_FOR_avx_cvtpd2dq256 = 2731,
CODE_FOR_avx_cvtpd2dq256_mask = 2732,
CODE_FOR_sse2_cvtpd2dq = 2734,
CODE_FOR_sse2_cvtpd2dq_mask = 2735,
CODE_FOR_ufix_notruncv8dfv8si2 = 2737,
CODE_FOR_ufix_notruncv8dfv8si2_round = 2738,
CODE_FOR_ufix_notruncv8dfv8si2_mask = 2739,
CODE_FOR_ufix_notruncv8dfv8si2_mask_round = 2740,
CODE_FOR_ufix_notruncv4dfv4si2 = 2741,
CODE_FOR_ufix_notruncv4dfv4si2_round = 2742,
CODE_FOR_ufix_notruncv4dfv4si2_mask = 2743,
CODE_FOR_ufix_notruncv4dfv4si2_mask_round = 2744,
CODE_FOR_ufix_notruncv2dfv2si2 = 2745,
CODE_FOR_ufix_notruncv2dfv2si2_mask = 2746,
CODE_FOR_fix_truncv8dfv8si2 = 2748,
CODE_FOR_fix_truncv8dfv8si2_round = 2749,
CODE_FOR_fix_truncv8dfv8si2_mask = 2750,
CODE_FOR_fix_truncv8dfv8si2_mask_round = 2751,
CODE_FOR_fixuns_truncv8dfv8si2 = 2752,
CODE_FOR_fixuns_truncv8dfv8si2_round = 2753,
CODE_FOR_fixuns_truncv8dfv8si2_mask = 2754,
CODE_FOR_fixuns_truncv8dfv8si2_mask_round = 2755,
CODE_FOR_ufix_truncv2dfv2si2 = 2756,
CODE_FOR_ufix_truncv2dfv2si2_mask = 2757,
CODE_FOR_fix_truncv4dfv4si2 = 2759,
CODE_FOR_fix_truncv4dfv4si2_mask = 2760,
CODE_FOR_ufix_truncv4dfv4si2 = 2761,
CODE_FOR_ufix_truncv4dfv4si2_mask = 2762,
CODE_FOR_fix_truncv8dfv8di2 = 2763,
CODE_FOR_fix_truncv8dfv8di2_round = 2764,
CODE_FOR_fix_truncv8dfv8di2_mask = 2765,
CODE_FOR_fix_truncv8dfv8di2_mask_round = 2766,
CODE_FOR_fixuns_truncv8dfv8di2 = 2767,
CODE_FOR_fixuns_truncv8dfv8di2_round = 2768,
CODE_FOR_fixuns_truncv8dfv8di2_mask = 2769,
CODE_FOR_fixuns_truncv8dfv8di2_mask_round = 2770,
CODE_FOR_fix_truncv4dfv4di2 = 2771,
CODE_FOR_fix_truncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv4dfv4di2_mask = 2772,
CODE_FOR_fix_truncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fixuns_truncv4dfv4di2 = 2773,
CODE_FOR_fixuns_truncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fixuns_truncv4dfv4di2_mask = 2774,
CODE_FOR_fixuns_truncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv2dfv2di2 = 2775,
CODE_FOR_fix_truncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv2dfv2di2_mask = 2776,
CODE_FOR_fix_truncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fixuns_truncv2dfv2di2 = 2777,
CODE_FOR_fixuns_truncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_fixuns_truncv2dfv2di2_mask = 2778,
CODE_FOR_fixuns_truncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv8dfv8di2 = 2779,
CODE_FOR_fix_notruncv8dfv8di2_round = 2780,
CODE_FOR_fix_notruncv8dfv8di2_mask = 2781,
CODE_FOR_fix_notruncv8dfv8di2_mask_round = 2782,
CODE_FOR_fix_notruncv4dfv4di2 = 2783,
CODE_FOR_fix_notruncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv4dfv4di2_mask = 2784,
CODE_FOR_fix_notruncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv2dfv2di2 = 2785,
CODE_FOR_fix_notruncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv2dfv2di2_mask = 2786,
CODE_FOR_fix_notruncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv8dfv8di2 = 2787,
CODE_FOR_ufix_notruncv8dfv8di2_round = 2788,
CODE_FOR_ufix_notruncv8dfv8di2_mask = 2789,
CODE_FOR_ufix_notruncv8dfv8di2_mask_round = 2790,
CODE_FOR_ufix_notruncv4dfv4di2 = 2791,
CODE_FOR_ufix_notruncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv4dfv4di2_mask = 2792,
CODE_FOR_ufix_notruncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv2dfv2di2 = 2793,
CODE_FOR_ufix_notruncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv2dfv2di2_mask = 2794,
CODE_FOR_ufix_notruncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv8sfv8di2 = 2795,
CODE_FOR_fix_truncv8sfv8di2_round = 2796,
CODE_FOR_fix_truncv8sfv8di2_mask = 2797,
CODE_FOR_fix_truncv8sfv8di2_mask_round = 2798,
CODE_FOR_fixuns_truncv8sfv8di2 = 2799,
CODE_FOR_fixuns_truncv8sfv8di2_round = 2800,
CODE_FOR_fixuns_truncv8sfv8di2_mask = 2801,
CODE_FOR_fixuns_truncv8sfv8di2_mask_round = 2802,
CODE_FOR_fix_truncv4sfv4di2 = 2803,
CODE_FOR_fix_truncv4sfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv4sfv4di2_mask = 2804,
CODE_FOR_fix_truncv4sfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fixuns_truncv4sfv4di2 = 2805,
CODE_FOR_fixuns_truncv4sfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fixuns_truncv4sfv4di2_mask = 2806,
CODE_FOR_fixuns_truncv4sfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_fix_truncv2sfv2di2 = 2807,
CODE_FOR_avx512dq_fix_truncv2sfv2di2_mask = 2808,
CODE_FOR_avx512dq_fixuns_truncv2sfv2di2 = 2809,
CODE_FOR_avx512dq_fixuns_truncv2sfv2di2_mask = 2810,
CODE_FOR_ufix_truncv8sfv8si2 = 2811,
CODE_FOR_ufix_truncv8sfv8si2_mask = 2812,
CODE_FOR_ufix_truncv4sfv4si2 = 2813,
CODE_FOR_ufix_truncv4sfv4si2_mask = 2814,
CODE_FOR_sse2_cvttpd2dq = 2815,
CODE_FOR_sse2_cvttpd2dq_mask = 2816,
CODE_FOR_sse2_cvtsd2ss = 2818,
CODE_FOR_sse2_cvtsd2ss_round = 2819,
CODE_FOR_sse2_cvtss2sd = 2821,
CODE_FOR_sse2_cvtss2sd_round = 2822,
CODE_FOR_avx512f_cvtpd2ps512_mask = 2826,
CODE_FOR_avx512f_cvtpd2ps512_mask_round = 2827,
CODE_FOR_avx_cvtpd2ps256 = 2828,
CODE_FOR_avx_cvtpd2ps256_mask = 2829,
CODE_FOR_truncv2dfv2sf2 = 2831,
CODE_FOR_avx512f_cvtps2pd512 = 2834,
CODE_FOR_avx512f_cvtps2pd512_round = 2835,
CODE_FOR_avx512f_cvtps2pd512_mask = 2836,
CODE_FOR_avx512f_cvtps2pd512_mask_round = 2837,
CODE_FOR_avx_cvtps2pd256 = 2838,
CODE_FOR_avx_cvtps2pd256_round = CODE_FOR_nothing,
CODE_FOR_avx_cvtps2pd256_mask = 2839,
CODE_FOR_avx_cvtps2pd256_mask_round = CODE_FOR_nothing,
CODE_FOR_vec_unpacks_lo_v16sf = 2841,
CODE_FOR_avx512bw_cvtb2maskv64qi = 2842,
CODE_FOR_avx512vl_cvtb2maskv16qi = 2843,
CODE_FOR_avx512vl_cvtb2maskv32qi = 2844,
CODE_FOR_avx512bw_cvtw2maskv32hi = 2845,
CODE_FOR_avx512vl_cvtw2maskv16hi = 2846,
CODE_FOR_avx512vl_cvtw2maskv8hi = 2847,
CODE_FOR_avx512f_cvtd2maskv16si = 2848,
CODE_FOR_avx512vl_cvtd2maskv8si = 2849,
CODE_FOR_avx512vl_cvtd2maskv4si = 2850,
CODE_FOR_avx512f_cvtq2maskv8di = 2851,
CODE_FOR_avx512vl_cvtq2maskv4di = 2852,
CODE_FOR_avx512vl_cvtq2maskv2di = 2853,
CODE_FOR_sse2_cvtps2pd = 2866,
CODE_FOR_sse2_cvtps2pd_mask = 2867,
CODE_FOR_extendv2sfv2df2 = 2868,
CODE_FOR_sse_movhlps = 2869,
CODE_FOR_sse_movlhps = 2870,
CODE_FOR_avx512f_unpckhps512_mask = 2872,
CODE_FOR_avx_unpckhps256 = 2873,
CODE_FOR_avx_unpckhps256_mask = 2874,
CODE_FOR_vec_interleave_highv4sf = 2875,
CODE_FOR_vec_interleave_highv4sf_mask = 2876,
CODE_FOR_avx512f_unpcklps512_mask = 2878,
CODE_FOR_avx_unpcklps256 = 2879,
CODE_FOR_avx_unpcklps256_mask = 2880,
CODE_FOR_unpcklps128_mask = 2881,
CODE_FOR_vec_interleave_lowv4sf = 2882,
CODE_FOR_avx_movshdup256 = 2883,
CODE_FOR_avx_movshdup256_mask = 2884,
CODE_FOR_sse3_movshdup = 2885,
CODE_FOR_sse3_movshdup_mask = 2886,
CODE_FOR_avx512f_movshdup512_mask = 2888,
CODE_FOR_avx_movsldup256 = 2889,
CODE_FOR_avx_movsldup256_mask = 2890,
CODE_FOR_sse3_movsldup = 2891,
CODE_FOR_sse3_movsldup_mask = 2892,
CODE_FOR_avx512f_movsldup512_mask = 2894,
CODE_FOR_avx_shufps256_1 = 2895,
CODE_FOR_avx_shufps256_1_mask = 2896,
CODE_FOR_sse_shufps_v4sf_mask = 2897,
CODE_FOR_sse_shufps_v4si = 2898,
CODE_FOR_sse_shufps_v4sf = 2899,
CODE_FOR_sse_storehps = 2900,
CODE_FOR_sse_loadhps = 2901,
CODE_FOR_sse_storelps = 2902,
CODE_FOR_sse_loadlps = 2903,
CODE_FOR_sse_movss = 2904,
CODE_FOR_avx2_vec_dupv8sf = 2905,
CODE_FOR_avx2_vec_dupv4sf = 2906,
CODE_FOR_avx2_vec_dupv8sf_1 = 2907,
CODE_FOR_avx512f_vec_dupv16sf_1 = 2908,
CODE_FOR_avx512f_vec_dupv8df_1 = 2909,
CODE_FOR_vec_setv4si_0 = 2914,
CODE_FOR_vec_setv4sf_0 = 2915,
CODE_FOR_vec_setv8si_0 = 2917,
CODE_FOR_vec_setv8sf_0 = 2918,
CODE_FOR_vec_setv16si_0 = 2919,
CODE_FOR_vec_setv16sf_0 = 2920,
CODE_FOR_sse4_1_insertps = 2921,
CODE_FOR_vec_setv2df_0 = 2922,
CODE_FOR_avx512dq_vextractf64x2_1_mask = 2926,
CODE_FOR_avx512dq_vextracti64x2_1_mask = 2927,
CODE_FOR_avx512f_vextractf32x4_1_mask = 2930,
CODE_FOR_avx512f_vextracti32x4_1_mask = 2931,
CODE_FOR_vec_extract_lo_v8df_mask = 2934,
CODE_FOR_vec_extract_lo_v8di_mask = 2935,
CODE_FOR_vec_extract_lo_v8df = 2936,
CODE_FOR_vec_extract_lo_v8di = 2937,
CODE_FOR_vec_extract_hi_v8df_mask = 2938,
CODE_FOR_vec_extract_hi_v8di_mask = 2939,
CODE_FOR_vec_extract_hi_v8df = 2940,
CODE_FOR_vec_extract_hi_v8di = 2941,
CODE_FOR_vec_extract_hi_v16sf_mask = 2942,
CODE_FOR_vec_extract_hi_v16si_mask = 2943,
CODE_FOR_vec_extract_hi_v16sf = 2944,
CODE_FOR_vec_extract_hi_v16si = 2945,
CODE_FOR_vec_extract_lo_v16sf_mask = 2946,
CODE_FOR_vec_extract_lo_v16si_mask = 2947,
CODE_FOR_vec_extract_lo_v16sf = 2948,
CODE_FOR_vec_extract_lo_v16si = 2949,
CODE_FOR_vec_extract_lo_v4di_mask = 2950,
CODE_FOR_vec_extract_lo_v4df_mask = 2951,
CODE_FOR_vec_extract_lo_v4di = 2952,
CODE_FOR_vec_extract_lo_v4df = 2953,
CODE_FOR_vec_extract_hi_v4di_mask = 2954,
CODE_FOR_vec_extract_hi_v4df_mask = 2955,
CODE_FOR_vec_extract_hi_v4di = 2956,
CODE_FOR_vec_extract_hi_v4df = 2957,
CODE_FOR_vec_extract_lo_v8si_mask = 2958,
CODE_FOR_vec_extract_lo_v8sf_mask = 2959,
CODE_FOR_vec_extract_lo_v8si = 2960,
CODE_FOR_vec_extract_lo_v8sf = 2961,
CODE_FOR_vec_extract_hi_v8si_mask = 2962,
CODE_FOR_vec_extract_hi_v8sf_mask = 2963,
CODE_FOR_vec_extract_hi_v8si = 2964,
CODE_FOR_vec_extract_hi_v8sf = 2965,
CODE_FOR_vec_extract_lo_v32hi = 2966,
CODE_FOR_vec_extract_hi_v32hi = 2967,
CODE_FOR_vec_extract_lo_v16hi = 2968,
CODE_FOR_vec_extract_hi_v16hi = 2969,
CODE_FOR_vec_extract_lo_v64qi = 2970,
CODE_FOR_vec_extract_hi_v64qi = 2971,
CODE_FOR_vec_extract_lo_v32qi = 2972,
CODE_FOR_vec_extract_hi_v32qi = 2973,
CODE_FOR_avx512f_unpckhpd512_mask = 2975,
CODE_FOR_avx_unpckhpd256 = 2976,
CODE_FOR_avx_unpckhpd256_mask = 2977,
CODE_FOR_avx512vl_unpckhpd128_mask = 2978,
CODE_FOR_avx512vl_unpcklpd128_mask = 2984,
CODE_FOR_avx512f_vmscalefv4sf = 2986,
CODE_FOR_avx512f_vmscalefv4sf_round = 2987,
CODE_FOR_avx512f_vmscalefv4sf_mask = 2988,
CODE_FOR_avx512f_vmscalefv4sf_mask_round = 2989,
CODE_FOR_avx512f_vmscalefv2df = 2990,
CODE_FOR_avx512f_vmscalefv2df_round = 2991,
CODE_FOR_avx512f_vmscalefv2df_mask = 2992,
CODE_FOR_avx512f_vmscalefv2df_mask_round = 2993,
CODE_FOR_avx512f_scalefv16sf = 2994,
CODE_FOR_avx512f_scalefv16sf_round = 2995,
CODE_FOR_avx512f_scalefv16sf_mask = 2996,
CODE_FOR_avx512f_scalefv16sf_mask_round = 2997,
CODE_FOR_avx512vl_scalefv8sf = 2998,
CODE_FOR_avx512vl_scalefv8sf_round = 2999,
CODE_FOR_avx512vl_scalefv8sf_mask = 3000,
CODE_FOR_avx512vl_scalefv8sf_mask_round = 3001,
CODE_FOR_avx512vl_scalefv4sf = 3002,
CODE_FOR_avx512vl_scalefv4sf_round = 3003,
CODE_FOR_avx512vl_scalefv4sf_mask = 3004,
CODE_FOR_avx512vl_scalefv4sf_mask_round = 3005,
CODE_FOR_avx512f_scalefv8df = 3006,
CODE_FOR_avx512f_scalefv8df_round = 3007,
CODE_FOR_avx512f_scalefv8df_mask = 3008,
CODE_FOR_avx512f_scalefv8df_mask_round = 3009,
CODE_FOR_avx512vl_scalefv4df = 3010,
CODE_FOR_avx512vl_scalefv4df_round = 3011,
CODE_FOR_avx512vl_scalefv4df_mask = 3012,
CODE_FOR_avx512vl_scalefv4df_mask_round = 3013,
CODE_FOR_avx512vl_scalefv2df = 3014,
CODE_FOR_avx512vl_scalefv2df_round = 3015,
CODE_FOR_avx512vl_scalefv2df_mask = 3016,
CODE_FOR_avx512vl_scalefv2df_mask_round = 3017,
CODE_FOR_avx512f_vternlogv16si = 3018,
CODE_FOR_avx512f_vternlogv16si_maskz_1 = 3019,
CODE_FOR_avx512vl_vternlogv8si = 3020,
CODE_FOR_avx512vl_vternlogv8si_maskz_1 = 3021,
CODE_FOR_avx512vl_vternlogv4si = 3022,
CODE_FOR_avx512vl_vternlogv4si_maskz_1 = 3023,
CODE_FOR_avx512f_vternlogv8di = 3024,
CODE_FOR_avx512f_vternlogv8di_maskz_1 = 3025,
CODE_FOR_avx512vl_vternlogv4di = 3026,
CODE_FOR_avx512vl_vternlogv4di_maskz_1 = 3027,
CODE_FOR_avx512vl_vternlogv2di = 3028,
CODE_FOR_avx512vl_vternlogv2di_maskz_1 = 3029,
CODE_FOR_avx512f_vternlogv16si_mask = 3030,
CODE_FOR_avx512vl_vternlogv8si_mask = 3031,
CODE_FOR_avx512vl_vternlogv4si_mask = 3032,
CODE_FOR_avx512f_vternlogv8di_mask = 3033,
CODE_FOR_avx512vl_vternlogv4di_mask = 3034,
CODE_FOR_avx512vl_vternlogv2di_mask = 3035,
CODE_FOR_avx512f_getexpv16sf = 3036,
CODE_FOR_avx512f_getexpv16sf_round = 3037,
CODE_FOR_avx512f_getexpv16sf_mask = 3038,
CODE_FOR_avx512f_getexpv16sf_mask_round = 3039,
CODE_FOR_avx512vl_getexpv8sf = 3040,
CODE_FOR_avx512vl_getexpv8sf_round = 3041,
CODE_FOR_avx512vl_getexpv8sf_mask = 3042,
CODE_FOR_avx512vl_getexpv8sf_mask_round = 3043,
CODE_FOR_avx512vl_getexpv4sf = 3044,
CODE_FOR_avx512vl_getexpv4sf_round = 3045,
CODE_FOR_avx512vl_getexpv4sf_mask = 3046,
CODE_FOR_avx512vl_getexpv4sf_mask_round = 3047,
CODE_FOR_avx512f_getexpv8df = 3048,
CODE_FOR_avx512f_getexpv8df_round = 3049,
CODE_FOR_avx512f_getexpv8df_mask = 3050,
CODE_FOR_avx512f_getexpv8df_mask_round = 3051,
CODE_FOR_avx512vl_getexpv4df = 3052,
CODE_FOR_avx512vl_getexpv4df_round = 3053,
CODE_FOR_avx512vl_getexpv4df_mask = 3054,
CODE_FOR_avx512vl_getexpv4df_mask_round = 3055,
CODE_FOR_avx512vl_getexpv2df = 3056,
CODE_FOR_avx512vl_getexpv2df_round = 3057,
CODE_FOR_avx512vl_getexpv2df_mask = 3058,
CODE_FOR_avx512vl_getexpv2df_mask_round = 3059,
CODE_FOR_avx512f_sgetexpv4sf = 3060,
CODE_FOR_avx512f_sgetexpv4sf_mask = 3061,
CODE_FOR_avx512f_sgetexpv4sf_round = 3062,
CODE_FOR_avx512f_sgetexpv4sf_mask_round = 3063,
CODE_FOR_avx512f_sgetexpv2df = 3064,
CODE_FOR_avx512f_sgetexpv2df_mask = 3065,
CODE_FOR_avx512f_sgetexpv2df_round = 3066,
CODE_FOR_avx512f_sgetexpv2df_mask_round = 3067,
CODE_FOR_avx512f_alignv16si_mask = 3069,
CODE_FOR_avx512vl_alignv8si_mask = 3071,
CODE_FOR_avx512vl_alignv4si_mask = 3073,
CODE_FOR_avx512f_alignv8di_mask = 3075,
CODE_FOR_avx512vl_alignv4di_mask = 3077,
CODE_FOR_avx512vl_alignv2di_mask = 3079,
CODE_FOR_avx512f_fixupimmv16sf = 3080,
CODE_FOR_avx512f_fixupimmv16sf_round = 3081,
CODE_FOR_avx512f_fixupimmv16sf_maskz_1 = 3082,
CODE_FOR_avx512f_fixupimmv16sf_maskz_1_round = 3083,
CODE_FOR_avx512vl_fixupimmv8sf = 3084,
CODE_FOR_avx512vl_fixupimmv8sf_round = 3085,
CODE_FOR_avx512vl_fixupimmv8sf_maskz_1 = 3086,
CODE_FOR_avx512vl_fixupimmv8sf_maskz_1_round = 3087,
CODE_FOR_avx512vl_fixupimmv4sf = 3088,
CODE_FOR_avx512vl_fixupimmv4sf_round = 3089,
CODE_FOR_avx512vl_fixupimmv4sf_maskz_1 = 3090,
CODE_FOR_avx512vl_fixupimmv4sf_maskz_1_round = 3091,
CODE_FOR_avx512f_fixupimmv8df = 3092,
CODE_FOR_avx512f_fixupimmv8df_round = 3093,
CODE_FOR_avx512f_fixupimmv8df_maskz_1 = 3094,
CODE_FOR_avx512f_fixupimmv8df_maskz_1_round = 3095,
CODE_FOR_avx512vl_fixupimmv4df = 3096,
CODE_FOR_avx512vl_fixupimmv4df_round = 3097,
CODE_FOR_avx512vl_fixupimmv4df_maskz_1 = 3098,
CODE_FOR_avx512vl_fixupimmv4df_maskz_1_round = 3099,
CODE_FOR_avx512vl_fixupimmv2df = 3100,
CODE_FOR_avx512vl_fixupimmv2df_round = 3101,
CODE_FOR_avx512vl_fixupimmv2df_maskz_1 = 3102,
CODE_FOR_avx512vl_fixupimmv2df_maskz_1_round = 3103,
CODE_FOR_avx512f_fixupimmv16sf_mask = 3104,
CODE_FOR_avx512f_fixupimmv16sf_mask_round = 3105,
CODE_FOR_avx512vl_fixupimmv8sf_mask = 3106,
CODE_FOR_avx512vl_fixupimmv8sf_mask_round = 3107,
CODE_FOR_avx512vl_fixupimmv4sf_mask = 3108,
CODE_FOR_avx512vl_fixupimmv4sf_mask_round = 3109,
CODE_FOR_avx512f_fixupimmv8df_mask = 3110,
CODE_FOR_avx512f_fixupimmv8df_mask_round = 3111,
CODE_FOR_avx512vl_fixupimmv4df_mask = 3112,
CODE_FOR_avx512vl_fixupimmv4df_mask_round = 3113,
CODE_FOR_avx512vl_fixupimmv2df_mask = 3114,
CODE_FOR_avx512vl_fixupimmv2df_mask_round = 3115,
CODE_FOR_avx512f_sfixupimmv4sf = 3116,
CODE_FOR_avx512f_sfixupimmv4sf_round = 3117,
CODE_FOR_avx512f_sfixupimmv4sf_maskz_1 = 3118,
CODE_FOR_avx512f_sfixupimmv4sf_maskz_1_round = 3119,
CODE_FOR_avx512f_sfixupimmv2df = 3120,
CODE_FOR_avx512f_sfixupimmv2df_round = 3121,
CODE_FOR_avx512f_sfixupimmv2df_maskz_1 = 3122,
CODE_FOR_avx512f_sfixupimmv2df_maskz_1_round = 3123,
CODE_FOR_avx512f_sfixupimmv4sf_mask = 3124,
CODE_FOR_avx512f_sfixupimmv4sf_mask_round = 3125,
CODE_FOR_avx512f_sfixupimmv2df_mask = 3126,
CODE_FOR_avx512f_sfixupimmv2df_mask_round = 3127,
CODE_FOR_avx512f_rndscalev16sf = 3128,
CODE_FOR_avx512f_rndscalev16sf_round = 3129,
CODE_FOR_avx512f_rndscalev16sf_mask = 3130,
CODE_FOR_avx512f_rndscalev16sf_mask_round = 3131,
CODE_FOR_avx512vl_rndscalev8sf = 3132,
CODE_FOR_avx512vl_rndscalev8sf_round = 3133,
CODE_FOR_avx512vl_rndscalev8sf_mask = 3134,
CODE_FOR_avx512vl_rndscalev8sf_mask_round = 3135,
CODE_FOR_avx512vl_rndscalev4sf = 3136,
CODE_FOR_avx512vl_rndscalev4sf_round = 3137,
CODE_FOR_avx512vl_rndscalev4sf_mask = 3138,
CODE_FOR_avx512vl_rndscalev4sf_mask_round = 3139,
CODE_FOR_avx512f_rndscalev8df = 3140,
CODE_FOR_avx512f_rndscalev8df_round = 3141,
CODE_FOR_avx512f_rndscalev8df_mask = 3142,
CODE_FOR_avx512f_rndscalev8df_mask_round = 3143,
CODE_FOR_avx512vl_rndscalev4df = 3144,
CODE_FOR_avx512vl_rndscalev4df_round = 3145,
CODE_FOR_avx512vl_rndscalev4df_mask = 3146,
CODE_FOR_avx512vl_rndscalev4df_mask_round = 3147,
CODE_FOR_avx512vl_rndscalev2df = 3148,
CODE_FOR_avx512vl_rndscalev2df_round = 3149,
CODE_FOR_avx512vl_rndscalev2df_mask = 3150,
CODE_FOR_avx512vl_rndscalev2df_mask_round = 3151,
CODE_FOR_avx512f_rndscalev4sf = 3152,
CODE_FOR_avx512f_rndscalev4sf_mask = 3153,
CODE_FOR_avx512f_rndscalev4sf_round = 3154,
CODE_FOR_avx512f_rndscalev4sf_mask_round = 3155,
CODE_FOR_avx512f_rndscalev2df = 3156,
CODE_FOR_avx512f_rndscalev2df_mask = 3157,
CODE_FOR_avx512f_rndscalev2df_round = 3158,
CODE_FOR_avx512f_rndscalev2df_mask_round = 3159,
CODE_FOR_avx512f_shufps512_1 = 3164,
CODE_FOR_avx512f_shufps512_1_mask = 3165,
CODE_FOR_avx512f_shufpd512_1 = 3166,
CODE_FOR_avx512f_shufpd512_1_mask = 3167,
CODE_FOR_avx_shufpd256_1 = 3168,
CODE_FOR_avx_shufpd256_1_mask = 3169,
CODE_FOR_sse2_shufpd_v2df_mask = 3170,
CODE_FOR_avx2_interleave_highv4di = 3171,
CODE_FOR_avx2_interleave_highv4di_mask = 3172,
CODE_FOR_avx512f_interleave_highv8di_mask = 3174,
CODE_FOR_vec_interleave_highv2di = 3175,
CODE_FOR_vec_interleave_highv2di_mask = 3176,
CODE_FOR_avx2_interleave_lowv4di = 3177,
CODE_FOR_avx2_interleave_lowv4di_mask = 3178,
CODE_FOR_avx512f_interleave_lowv8di_mask = 3180,
CODE_FOR_vec_interleave_lowv2di = 3181,
CODE_FOR_vec_interleave_lowv2di_mask = 3182,
CODE_FOR_sse2_shufpd_v2di = 3183,
CODE_FOR_sse2_shufpd_v2df = 3184,
CODE_FOR_sse2_storehpd = 3185,
CODE_FOR_sse2_storelpd = 3187,
CODE_FOR_sse2_loadhpd = 3189,
CODE_FOR_sse2_loadlpd = 3190,
CODE_FOR_sse2_movsd = 3191,
CODE_FOR_vec_dupv2df = 3192,
CODE_FOR_vec_dupv2df_mask = 3193,
CODE_FOR_vec_concatv2df = 3194,
CODE_FOR_vec_setv8df_0 = 3195,
CODE_FOR_vec_setv4df_0 = 3196,
CODE_FOR_avx512f_ss_truncatev16siv16qi2_mask = 3209,
CODE_FOR_avx512f_truncatev16siv16qi2_mask = 3210,
CODE_FOR_avx512f_us_truncatev16siv16qi2_mask = 3211,
CODE_FOR_avx512f_ss_truncatev16siv16hi2_mask = 3212,
CODE_FOR_avx512f_truncatev16siv16hi2_mask = 3213,
CODE_FOR_avx512f_us_truncatev16siv16hi2_mask = 3214,
CODE_FOR_avx512f_ss_truncatev8div8si2_mask = 3215,
CODE_FOR_avx512f_truncatev8div8si2_mask = 3216,
CODE_FOR_avx512f_us_truncatev8div8si2_mask = 3217,
CODE_FOR_avx512f_ss_truncatev8div8hi2_mask = 3218,
CODE_FOR_avx512f_truncatev8div8hi2_mask = 3219,
CODE_FOR_avx512f_us_truncatev8div8hi2_mask = 3220,
CODE_FOR_avx512bw_ss_truncatev32hiv32qi2 = 3221,
CODE_FOR_avx512bw_truncatev32hiv32qi2 = 3222,
CODE_FOR_avx512bw_us_truncatev32hiv32qi2 = 3223,
CODE_FOR_avx512bw_ss_truncatev32hiv32qi2_mask = 3224,
CODE_FOR_avx512bw_truncatev32hiv32qi2_mask = 3225,
CODE_FOR_avx512bw_us_truncatev32hiv32qi2_mask = 3226,
CODE_FOR_avx512vl_ss_truncatev4div4si2_mask = 3236,
CODE_FOR_avx512vl_truncatev4div4si2_mask = 3237,
CODE_FOR_avx512vl_us_truncatev4div4si2_mask = 3238,
CODE_FOR_avx512vl_ss_truncatev8siv8hi2_mask = 3239,
CODE_FOR_avx512vl_truncatev8siv8hi2_mask = 3240,
CODE_FOR_avx512vl_us_truncatev8siv8hi2_mask = 3241,
CODE_FOR_avx512vl_ss_truncatev16hiv16qi2_mask = 3242,
CODE_FOR_avx512vl_truncatev16hiv16qi2_mask = 3243,
CODE_FOR_avx512vl_us_truncatev16hiv16qi2_mask = 3244,
CODE_FOR_avx512vl_ss_truncatev4div4qi2 = 3245,
CODE_FOR_avx512vl_truncatev4div4qi2 = 3246,
CODE_FOR_avx512vl_us_truncatev4div4qi2 = 3247,
CODE_FOR_avx512vl_ss_truncatev2div2qi2 = 3248,
CODE_FOR_avx512vl_truncatev2div2qi2 = 3249,
CODE_FOR_avx512vl_us_truncatev2div2qi2 = 3250,
CODE_FOR_avx512vl_ss_truncatev8siv8qi2 = 3251,
CODE_FOR_avx512vl_truncatev8siv8qi2 = 3252,
CODE_FOR_avx512vl_us_truncatev8siv8qi2 = 3253,
CODE_FOR_avx512vl_ss_truncatev4siv4qi2 = 3254,
CODE_FOR_avx512vl_truncatev4siv4qi2 = 3255,
CODE_FOR_avx512vl_us_truncatev4siv4qi2 = 3256,
CODE_FOR_avx512vl_ss_truncatev8hiv8qi2 = 3257,
CODE_FOR_avx512vl_truncatev8hiv8qi2 = 3258,
CODE_FOR_avx512vl_us_truncatev8hiv8qi2 = 3259,
CODE_FOR_avx512vl_ss_truncatev2div2qi2_mask = 3266,
CODE_FOR_avx512vl_truncatev2div2qi2_mask = 3267,
CODE_FOR_avx512vl_us_truncatev2div2qi2_mask = 3268,
CODE_FOR_avx512vl_ss_truncatev2div2qi2_mask_store_2 = 3275,
CODE_FOR_avx512vl_truncatev2div2qi2_mask_store_2 = 3276,
CODE_FOR_avx512vl_us_truncatev2div2qi2_mask_store_2 = 3277,
CODE_FOR_avx512vl_ss_truncatev4siv4qi2_mask = 3290,
CODE_FOR_avx512vl_truncatev4siv4qi2_mask = 3291,
CODE_FOR_avx512vl_us_truncatev4siv4qi2_mask = 3292,
CODE_FOR_avx512vl_ss_truncatev4div4qi2_mask = 3293,
CODE_FOR_avx512vl_truncatev4div4qi2_mask = 3294,
CODE_FOR_avx512vl_us_truncatev4div4qi2_mask = 3295,
CODE_FOR_avx512vl_ss_truncatev4siv4qi2_mask_store_2 = 3308,
CODE_FOR_avx512vl_truncatev4siv4qi2_mask_store_2 = 3309,
CODE_FOR_avx512vl_us_truncatev4siv4qi2_mask_store_2 = 3310,
CODE_FOR_avx512vl_ss_truncatev4div4qi2_mask_store_2 = 3311,
CODE_FOR_avx512vl_truncatev4div4qi2_mask_store_2 = 3312,
CODE_FOR_avx512vl_us_truncatev4div4qi2_mask_store_2 = 3313,
CODE_FOR_avx512vl_ss_truncatev8hiv8qi2_mask = 3326,
CODE_FOR_avx512vl_truncatev8hiv8qi2_mask = 3327,
CODE_FOR_avx512vl_us_truncatev8hiv8qi2_mask = 3328,
CODE_FOR_avx512vl_ss_truncatev8siv8qi2_mask = 3329,
CODE_FOR_avx512vl_truncatev8siv8qi2_mask = 3330,
CODE_FOR_avx512vl_us_truncatev8siv8qi2_mask = 3331,
CODE_FOR_avx512vl_ss_truncatev8hiv8qi2_mask_store_2 = 3344,
CODE_FOR_avx512vl_truncatev8hiv8qi2_mask_store_2 = 3345,
CODE_FOR_avx512vl_us_truncatev8hiv8qi2_mask_store_2 = 3346,
CODE_FOR_avx512vl_ss_truncatev8siv8qi2_mask_store_2 = 3347,
CODE_FOR_avx512vl_truncatev8siv8qi2_mask_store_2 = 3348,
CODE_FOR_avx512vl_us_truncatev8siv8qi2_mask_store_2 = 3349,
CODE_FOR_avx512vl_ss_truncatev4div4hi2 = 3350,
CODE_FOR_avx512vl_truncatev4div4hi2 = 3351,
CODE_FOR_avx512vl_us_truncatev4div4hi2 = 3352,
CODE_FOR_avx512vl_ss_truncatev2div2hi2 = 3353,
CODE_FOR_avx512vl_truncatev2div2hi2 = 3354,
CODE_FOR_avx512vl_us_truncatev2div2hi2 = 3355,
CODE_FOR_avx512vl_ss_truncatev4siv4hi2 = 3356,
CODE_FOR_avx512vl_truncatev4siv4hi2 = 3357,
CODE_FOR_avx512vl_us_truncatev4siv4hi2 = 3358,
CODE_FOR_avx512vl_ss_truncatev4siv4hi2_mask = 3371,
CODE_FOR_avx512vl_truncatev4siv4hi2_mask = 3372,
CODE_FOR_avx512vl_us_truncatev4siv4hi2_mask = 3373,
CODE_FOR_avx512vl_ss_truncatev4div4hi2_mask = 3374,
CODE_FOR_avx512vl_truncatev4div4hi2_mask = 3375,
CODE_FOR_avx512vl_us_truncatev4div4hi2_mask = 3376,
CODE_FOR_avx512vl_ss_truncatev4siv4hi2_mask_store_2 = 3389,
CODE_FOR_avx512vl_truncatev4siv4hi2_mask_store_2 = 3390,
CODE_FOR_avx512vl_us_truncatev4siv4hi2_mask_store_2 = 3391,
CODE_FOR_avx512vl_ss_truncatev4div4hi2_mask_store_2 = 3392,
CODE_FOR_avx512vl_truncatev4div4hi2_mask_store_2 = 3393,
CODE_FOR_avx512vl_us_truncatev4div4hi2_mask_store_2 = 3394,
CODE_FOR_avx512vl_ss_truncatev2div2hi2_mask = 3401,
CODE_FOR_avx512vl_truncatev2div2hi2_mask = 3402,
CODE_FOR_avx512vl_us_truncatev2div2hi2_mask = 3403,
CODE_FOR_avx512vl_ss_truncatev2div2hi2_mask_store_2 = 3410,
CODE_FOR_avx512vl_truncatev2div2hi2_mask_store_2 = 3411,
CODE_FOR_avx512vl_us_truncatev2div2hi2_mask_store_2 = 3412,
CODE_FOR_avx512vl_ss_truncatev2div2si2 = 3413,
CODE_FOR_avx512vl_truncatev2div2si2 = 3414,
CODE_FOR_avx512vl_us_truncatev2div2si2 = 3415,
CODE_FOR_avx512vl_ss_truncatev2div2si2_mask = 3422,
CODE_FOR_avx512vl_truncatev2div2si2_mask = 3423,
CODE_FOR_avx512vl_us_truncatev2div2si2_mask = 3424,
CODE_FOR_avx512vl_ss_truncatev2div2si2_mask_store_2 = 3431,
CODE_FOR_avx512vl_truncatev2div2si2_mask_store_2 = 3432,
CODE_FOR_avx512vl_us_truncatev2div2si2_mask_store_2 = 3433,
CODE_FOR_avx512f_ss_truncatev8div16qi2 = 3434,
CODE_FOR_avx512f_truncatev8div16qi2 = 3435,
CODE_FOR_avx512f_us_truncatev8div16qi2 = 3436,
CODE_FOR_avx512f_ss_truncatev8div16qi2_mask = 3443,
CODE_FOR_avx512f_truncatev8div16qi2_mask = 3444,
CODE_FOR_avx512f_us_truncatev8div16qi2_mask = 3445,
CODE_FOR_avx512f_ss_truncatev8div16qi2_mask_store_2 = 3452,
CODE_FOR_avx512f_truncatev8div16qi2_mask_store_2 = 3453,
CODE_FOR_avx512f_us_truncatev8div16qi2_mask_store_2 = 3454,
CODE_FOR_avx512bw_pmaddwd512v32hi = 3593,
CODE_FOR_avx512bw_pmaddwd512v32hi_mask = 3594,
CODE_FOR_avx512bw_pmaddwd512v16hi = 3595,
CODE_FOR_avx512bw_pmaddwd512v16hi_mask = 3596,
CODE_FOR_avx512bw_pmaddwd512v8hi = 3597,
CODE_FOR_avx512bw_pmaddwd512v8hi_mask = 3598,
CODE_FOR_avx512dq_mulv8di3 = 3601,
CODE_FOR_avx512dq_mulv8di3_mask = 3602,
CODE_FOR_avx512dq_mulv4di3 = 3603,
CODE_FOR_avx512dq_mulv4di3_mask = 3604,
CODE_FOR_avx512dq_mulv2di3 = 3605,
CODE_FOR_avx512dq_mulv2di3_mask = 3606,
CODE_FOR_ashrv16hi3_mask = 3614,
CODE_FOR_ashrv8hi3_mask = 3616,
CODE_FOR_ashrv8si3_mask = 3618,
CODE_FOR_ashrv4si3_mask = 3620,
CODE_FOR_ashrv2di3_mask = 3622,
CODE_FOR_ashrv16hi3 = 3623,
CODE_FOR_ashrv8hi3 = 3624,
CODE_FOR_ashrv8si3 = 3625,
CODE_FOR_ashrv4si3 = 3626,
CODE_FOR_ashrv32hi3 = 3627,
CODE_FOR_ashrv32hi3_mask = 3628,
CODE_FOR_ashrv4di3 = 3629,
CODE_FOR_ashrv4di3_mask = 3630,
CODE_FOR_ashrv16si3 = 3631,
CODE_FOR_ashrv16si3_mask = 3632,
CODE_FOR_ashrv8di3 = 3633,
CODE_FOR_ashrv8di3_mask = 3634,
CODE_FOR_ashlv16hi3_mask = 3636,
CODE_FOR_lshrv16hi3_mask = 3638,
CODE_FOR_ashlv8hi3_mask = 3640,
CODE_FOR_lshrv8hi3_mask = 3642,
CODE_FOR_ashlv8si3_mask = 3644,
CODE_FOR_lshrv8si3_mask = 3646,
CODE_FOR_ashlv4si3_mask = 3648,
CODE_FOR_lshrv4si3_mask = 3650,
CODE_FOR_ashlv4di3_mask = 3652,
CODE_FOR_lshrv4di3_mask = 3654,
CODE_FOR_ashlv2di3_mask = 3656,
CODE_FOR_lshrv2di3_mask = 3658,
CODE_FOR_ashlv16hi3 = 3659,
CODE_FOR_lshrv16hi3 = 3660,
CODE_FOR_ashlv8hi3 = 3661,
CODE_FOR_lshrv8hi3 = 3662,
CODE_FOR_ashlv8si3 = 3663,
CODE_FOR_lshrv8si3 = 3664,
CODE_FOR_ashlv4si3 = 3665,
CODE_FOR_lshrv4si3 = 3666,
CODE_FOR_ashlv4di3 = 3667,
CODE_FOR_lshrv4di3 = 3668,
CODE_FOR_ashlv2di3 = 3669,
CODE_FOR_lshrv2di3 = 3670,
CODE_FOR_ashlv32hi3 = 3671,
CODE_FOR_ashlv32hi3_mask = 3672,
CODE_FOR_lshrv32hi3 = 3673,
CODE_FOR_lshrv32hi3_mask = 3674,
CODE_FOR_ashlv16si3 = 3675,
CODE_FOR_ashlv16si3_mask = 3676,
CODE_FOR_lshrv16si3 = 3677,
CODE_FOR_lshrv16si3_mask = 3678,
CODE_FOR_ashlv8di3 = 3679,
CODE_FOR_ashlv8di3_mask = 3680,
CODE_FOR_lshrv8di3 = 3681,
CODE_FOR_lshrv8di3_mask = 3682,
CODE_FOR_avx512bw_ashlv4ti3 = 3683,
CODE_FOR_avx512bw_lshrv4ti3 = 3684,
CODE_FOR_avx512bw_ashlv2ti3 = 3685,
CODE_FOR_avx512bw_lshrv2ti3 = 3686,
CODE_FOR_avx512bw_ashlv1ti3 = 3687,
CODE_FOR_avx512bw_lshrv1ti3 = 3688,
CODE_FOR_avx2_ashlv2ti3 = 3689,
CODE_FOR_avx2_lshrv2ti3 = 3690,
CODE_FOR_sse2_ashlv1ti3 = 3691,
CODE_FOR_sse2_lshrv1ti3 = 3692,
CODE_FOR_avx512f_rolvv16si = 3693,
CODE_FOR_avx512f_rolvv16si_mask = 3694,
CODE_FOR_avx512f_rorvv16si = 3695,
CODE_FOR_avx512f_rorvv16si_mask = 3696,
CODE_FOR_avx512vl_rolvv8si = 3697,
CODE_FOR_avx512vl_rolvv8si_mask = 3698,
CODE_FOR_avx512vl_rorvv8si = 3699,
CODE_FOR_avx512vl_rorvv8si_mask = 3700,
CODE_FOR_avx512vl_rolvv4si = 3701,
CODE_FOR_avx512vl_rolvv4si_mask = 3702,
CODE_FOR_avx512vl_rorvv4si = 3703,
CODE_FOR_avx512vl_rorvv4si_mask = 3704,
CODE_FOR_avx512f_rolvv8di = 3705,
CODE_FOR_avx512f_rolvv8di_mask = 3706,
CODE_FOR_avx512f_rorvv8di = 3707,
CODE_FOR_avx512f_rorvv8di_mask = 3708,
CODE_FOR_avx512vl_rolvv4di = 3709,
CODE_FOR_avx512vl_rolvv4di_mask = 3710,
CODE_FOR_avx512vl_rorvv4di = 3711,
CODE_FOR_avx512vl_rorvv4di_mask = 3712,
CODE_FOR_avx512vl_rolvv2di = 3713,
CODE_FOR_avx512vl_rolvv2di_mask = 3714,
CODE_FOR_avx512vl_rorvv2di = 3715,
CODE_FOR_avx512vl_rorvv2di_mask = 3716,
CODE_FOR_avx512f_rolv16si = 3717,
CODE_FOR_avx512f_rolv16si_mask = 3718,
CODE_FOR_avx512f_rorv16si = 3719,
CODE_FOR_avx512f_rorv16si_mask = 3720,
CODE_FOR_avx512vl_rolv8si = 3721,
CODE_FOR_avx512vl_rolv8si_mask = 3722,
CODE_FOR_avx512vl_rorv8si = 3723,
CODE_FOR_avx512vl_rorv8si_mask = 3724,
CODE_FOR_avx512vl_rolv4si = 3725,
CODE_FOR_avx512vl_rolv4si_mask = 3726,
CODE_FOR_avx512vl_rorv4si = 3727,
CODE_FOR_avx512vl_rorv4si_mask = 3728,
CODE_FOR_avx512f_rolv8di = 3729,
CODE_FOR_avx512f_rolv8di_mask = 3730,
CODE_FOR_avx512f_rorv8di = 3731,
CODE_FOR_avx512f_rorv8di_mask = 3732,
CODE_FOR_avx512vl_rolv4di = 3733,
CODE_FOR_avx512vl_rolv4di_mask = 3734,
CODE_FOR_avx512vl_rorv4di = 3735,
CODE_FOR_avx512vl_rorv4di_mask = 3736,
CODE_FOR_avx512vl_rolv2di = 3737,
CODE_FOR_avx512vl_rolv2di_mask = 3738,
CODE_FOR_avx512vl_rorv2di = 3739,
CODE_FOR_avx512vl_rorv2di_mask = 3740,
CODE_FOR_smaxv64qi3_mask = 3802,
CODE_FOR_sminv64qi3_mask = 3804,
CODE_FOR_umaxv64qi3_mask = 3806,
CODE_FOR_uminv64qi3_mask = 3808,
CODE_FOR_smaxv16qi3_mask = 3810,
CODE_FOR_sminv16qi3_mask = 3812,
CODE_FOR_umaxv16qi3_mask = 3814,
CODE_FOR_uminv16qi3_mask = 3816,
CODE_FOR_smaxv32qi3_mask = 3818,
CODE_FOR_sminv32qi3_mask = 3820,
CODE_FOR_umaxv32qi3_mask = 3822,
CODE_FOR_uminv32qi3_mask = 3824,
CODE_FOR_smaxv32hi3_mask = 3826,
CODE_FOR_sminv32hi3_mask = 3828,
CODE_FOR_umaxv32hi3_mask = 3830,
CODE_FOR_uminv32hi3_mask = 3832,
CODE_FOR_smaxv16hi3_mask = 3834,
CODE_FOR_sminv16hi3_mask = 3836,
CODE_FOR_umaxv16hi3_mask = 3838,
CODE_FOR_uminv16hi3_mask = 3840,
CODE_FOR_smaxv8hi3_mask = 3842,
CODE_FOR_sminv8hi3_mask = 3844,
CODE_FOR_umaxv8hi3_mask = 3846,
CODE_FOR_uminv8hi3_mask = 3848,
CODE_FOR_avx512bw_eqv64qi3_1 = 3873,
CODE_FOR_avx512bw_eqv64qi3_mask_1 = 3874,
CODE_FOR_avx512vl_eqv16qi3_1 = 3875,
CODE_FOR_avx512vl_eqv16qi3_mask_1 = 3876,
CODE_FOR_avx512vl_eqv32qi3_1 = 3877,
CODE_FOR_avx512vl_eqv32qi3_mask_1 = 3878,
CODE_FOR_avx512bw_eqv32hi3_1 = 3879,
CODE_FOR_avx512bw_eqv32hi3_mask_1 = 3880,
CODE_FOR_avx512vl_eqv16hi3_1 = 3881,
CODE_FOR_avx512vl_eqv16hi3_mask_1 = 3882,
CODE_FOR_avx512vl_eqv8hi3_1 = 3883,
CODE_FOR_avx512vl_eqv8hi3_mask_1 = 3884,
CODE_FOR_avx512f_eqv16si3_1 = 3885,
CODE_FOR_avx512f_eqv16si3_mask_1 = 3886,
CODE_FOR_avx512vl_eqv8si3_1 = 3887,
CODE_FOR_avx512vl_eqv8si3_mask_1 = 3888,
CODE_FOR_avx512vl_eqv4si3_1 = 3889,
CODE_FOR_avx512vl_eqv4si3_mask_1 = 3890,
CODE_FOR_avx512f_eqv8di3_1 = 3891,
CODE_FOR_avx512f_eqv8di3_mask_1 = 3892,
CODE_FOR_avx512vl_eqv4di3_1 = 3893,
CODE_FOR_avx512vl_eqv4di3_mask_1 = 3894,
CODE_FOR_avx512vl_eqv2di3_1 = 3895,
CODE_FOR_avx512vl_eqv2di3_mask_1 = 3896,
CODE_FOR_sse4_2_gtv2di3 = 3901,
CODE_FOR_avx2_gtv32qi3 = 3902,
CODE_FOR_avx2_gtv16hi3 = 3903,
CODE_FOR_avx2_gtv8si3 = 3904,
CODE_FOR_avx2_gtv4di3 = 3905,
CODE_FOR_avx512f_gtv16si3 = 3906,
CODE_FOR_avx512f_gtv16si3_mask = 3907,
CODE_FOR_avx512vl_gtv8si3 = 3908,
CODE_FOR_avx512vl_gtv8si3_mask = 3909,
CODE_FOR_avx512vl_gtv4si3 = 3910,
CODE_FOR_avx512vl_gtv4si3_mask = 3911,
CODE_FOR_avx512f_gtv8di3 = 3912,
CODE_FOR_avx512f_gtv8di3_mask = 3913,
CODE_FOR_avx512vl_gtv4di3 = 3914,
CODE_FOR_avx512vl_gtv4di3_mask = 3915,
CODE_FOR_avx512vl_gtv2di3 = 3916,
CODE_FOR_avx512vl_gtv2di3_mask = 3917,
CODE_FOR_avx512bw_gtv64qi3 = 3918,
CODE_FOR_avx512bw_gtv64qi3_mask = 3919,
CODE_FOR_avx512vl_gtv16qi3 = 3920,
CODE_FOR_avx512vl_gtv16qi3_mask = 3921,
CODE_FOR_avx512vl_gtv32qi3 = 3922,
CODE_FOR_avx512vl_gtv32qi3_mask = 3923,
CODE_FOR_avx512bw_gtv32hi3 = 3924,
CODE_FOR_avx512bw_gtv32hi3_mask = 3925,
CODE_FOR_avx512vl_gtv16hi3 = 3926,
CODE_FOR_avx512vl_gtv16hi3_mask = 3927,
CODE_FOR_avx512vl_gtv8hi3 = 3928,
CODE_FOR_avx512vl_gtv8hi3_mask = 3929,
CODE_FOR_sse2_gtv16qi3 = 3930,
CODE_FOR_sse2_gtv8hi3 = 3931,
CODE_FOR_sse2_gtv4si3 = 3932,
CODE_FOR_one_cmplv16si2_mask = 3934,
CODE_FOR_one_cmplv8di2_mask = 3936,
CODE_FOR_one_cmplv64qi2_mask = CODE_FOR_nothing,
CODE_FOR_one_cmplv32qi2_mask = CODE_FOR_nothing,
CODE_FOR_one_cmplv16qi2_mask = CODE_FOR_nothing,
CODE_FOR_one_cmplv32hi2_mask = CODE_FOR_nothing,
CODE_FOR_one_cmplv16hi2_mask = CODE_FOR_nothing,
CODE_FOR_one_cmplv8hi2_mask = CODE_FOR_nothing,
CODE_FOR_one_cmplv8si2_mask = 3944,
CODE_FOR_one_cmplv4si2_mask = 3946,
CODE_FOR_one_cmplv4di2_mask = 3948,
CODE_FOR_one_cmplv2di2_mask = 3950,
CODE_FOR_andv16si3_mask = 3976,
CODE_FOR_iorv16si3_mask = 3978,
CODE_FOR_xorv16si3_mask = 3980,
CODE_FOR_andv8si3_mask = 3982,
CODE_FOR_iorv8si3_mask = 3984,
CODE_FOR_xorv8si3_mask = 3986,
CODE_FOR_andv4si3_mask = 3988,
CODE_FOR_iorv4si3_mask = 3990,
CODE_FOR_xorv4si3_mask = 3992,
CODE_FOR_andv8di3_mask = 3994,
CODE_FOR_iorv8di3_mask = 3996,
CODE_FOR_xorv8di3_mask = 3998,
CODE_FOR_andv4di3_mask = 4000,
CODE_FOR_iorv4di3_mask = 4002,
CODE_FOR_xorv4di3_mask = 4004,
CODE_FOR_andv2di3_mask = 4006,
CODE_FOR_iorv2di3_mask = 4008,
CODE_FOR_xorv2di3_mask = 4010,
CODE_FOR_avx512bw_testmv64qi3 = 4065,
CODE_FOR_avx512bw_testmv64qi3_mask = 4066,
CODE_FOR_avx512vl_testmv32qi3 = 4067,
CODE_FOR_avx512vl_testmv32qi3_mask = 4068,
CODE_FOR_avx512vl_testmv16qi3 = 4069,
CODE_FOR_avx512vl_testmv16qi3_mask = 4070,
CODE_FOR_avx512bw_testmv32hi3 = 4071,
CODE_FOR_avx512bw_testmv32hi3_mask = 4072,
CODE_FOR_avx512vl_testmv16hi3 = 4073,
CODE_FOR_avx512vl_testmv16hi3_mask = 4074,
CODE_FOR_avx512vl_testmv8hi3 = 4075,
CODE_FOR_avx512vl_testmv8hi3_mask = 4076,
CODE_FOR_avx512f_testmv16si3 = 4077,
CODE_FOR_avx512f_testmv16si3_mask = 4078,
CODE_FOR_avx512vl_testmv8si3 = 4079,
CODE_FOR_avx512vl_testmv8si3_mask = 4080,
CODE_FOR_avx512vl_testmv4si3 = 4081,
CODE_FOR_avx512vl_testmv4si3_mask = 4082,
CODE_FOR_avx512f_testmv8di3 = 4083,
CODE_FOR_avx512f_testmv8di3_mask = 4084,
CODE_FOR_avx512vl_testmv4di3 = 4085,
CODE_FOR_avx512vl_testmv4di3_mask = 4086,
CODE_FOR_avx512vl_testmv2di3 = 4087,
CODE_FOR_avx512vl_testmv2di3_mask = 4088,
CODE_FOR_avx512bw_testnmv64qi3 = 4089,
CODE_FOR_avx512bw_testnmv64qi3_mask = 4090,
CODE_FOR_avx512vl_testnmv32qi3 = 4091,
CODE_FOR_avx512vl_testnmv32qi3_mask = 4092,
CODE_FOR_avx512vl_testnmv16qi3 = 4093,
CODE_FOR_avx512vl_testnmv16qi3_mask = 4094,
CODE_FOR_avx512bw_testnmv32hi3 = 4095,
CODE_FOR_avx512bw_testnmv32hi3_mask = 4096,
CODE_FOR_avx512vl_testnmv16hi3 = 4097,
CODE_FOR_avx512vl_testnmv16hi3_mask = 4098,
CODE_FOR_avx512vl_testnmv8hi3 = 4099,
CODE_FOR_avx512vl_testnmv8hi3_mask = 4100,
CODE_FOR_avx512f_testnmv16si3 = 4101,
CODE_FOR_avx512f_testnmv16si3_mask = 4102,
CODE_FOR_avx512vl_testnmv8si3 = 4103,
CODE_FOR_avx512vl_testnmv8si3_mask = 4104,
CODE_FOR_avx512vl_testnmv4si3 = 4105,
CODE_FOR_avx512vl_testnmv4si3_mask = 4106,
CODE_FOR_avx512f_testnmv8di3 = 4107,
CODE_FOR_avx512f_testnmv8di3_mask = 4108,
CODE_FOR_avx512vl_testnmv4di3 = 4109,
CODE_FOR_avx512vl_testnmv4di3_mask = 4110,
CODE_FOR_avx512vl_testnmv2di3 = 4111,
CODE_FOR_avx512vl_testnmv2di3_mask = 4112,
CODE_FOR_avx512bw_packsswb = 4257,
CODE_FOR_avx512bw_packsswb_mask = 4258,
CODE_FOR_avx2_packsswb = 4259,
CODE_FOR_avx2_packsswb_mask = 4260,
CODE_FOR_sse2_packsswb = 4261,
CODE_FOR_sse2_packsswb_mask = 4262,
CODE_FOR_avx512bw_packssdw = 4263,
CODE_FOR_avx512bw_packssdw_mask = 4264,
CODE_FOR_avx2_packssdw = 4265,
CODE_FOR_avx2_packssdw_mask = 4266,
CODE_FOR_sse2_packssdw = 4267,
CODE_FOR_sse2_packssdw_mask = 4268,
CODE_FOR_avx512bw_packuswb = 4269,
CODE_FOR_avx512bw_packuswb_mask = 4270,
CODE_FOR_avx2_packuswb = 4271,
CODE_FOR_avx2_packuswb_mask = 4272,
CODE_FOR_sse2_packuswb = 4273,
CODE_FOR_sse2_packuswb_mask = 4274,
CODE_FOR_avx512bw_interleave_highv64qi = 4275,
CODE_FOR_avx512bw_interleave_highv64qi_mask = 4276,
CODE_FOR_avx2_interleave_highv32qi = 4277,
CODE_FOR_avx2_interleave_highv32qi_mask = 4278,
CODE_FOR_vec_interleave_highv16qi = 4279,
CODE_FOR_vec_interleave_highv16qi_mask = 4280,
CODE_FOR_avx512bw_interleave_lowv64qi = 4281,
CODE_FOR_avx512bw_interleave_lowv64qi_mask = 4282,
CODE_FOR_avx2_interleave_lowv32qi = 4283,
CODE_FOR_avx2_interleave_lowv32qi_mask = 4284,
CODE_FOR_vec_interleave_lowv16qi = 4285,
CODE_FOR_vec_interleave_lowv16qi_mask = 4286,
CODE_FOR_avx512bw_interleave_highv32hi = 4287,
CODE_FOR_avx512bw_interleave_highv32hi_mask = 4288,
CODE_FOR_avx2_interleave_highv16hi = 4289,
CODE_FOR_avx2_interleave_highv16hi_mask = 4290,
CODE_FOR_vec_interleave_highv8hi = 4291,
CODE_FOR_vec_interleave_highv8hi_mask = 4292,
CODE_FOR_avx512bw_interleave_lowv32hi_mask = 4294,
CODE_FOR_avx2_interleave_lowv16hi = 4295,
CODE_FOR_avx2_interleave_lowv16hi_mask = 4296,
CODE_FOR_vec_interleave_lowv8hi = 4297,
CODE_FOR_vec_interleave_lowv8hi_mask = 4298,
CODE_FOR_avx2_interleave_highv8si = 4299,
CODE_FOR_avx2_interleave_highv8si_mask = 4300,
CODE_FOR_avx512f_interleave_highv16si_mask = 4302,
CODE_FOR_vec_interleave_highv4si = 4303,
CODE_FOR_vec_interleave_highv4si_mask = 4304,
CODE_FOR_avx2_interleave_lowv8si = 4305,
CODE_FOR_avx2_interleave_lowv8si_mask = 4306,
CODE_FOR_avx512f_interleave_lowv16si_mask = 4308,
CODE_FOR_vec_interleave_lowv4si = 4309,
CODE_FOR_vec_interleave_lowv4si_mask = 4310,
CODE_FOR_sse4_1_pinsrb = 4311,
CODE_FOR_sse2_pinsrw = 4312,
CODE_FOR_sse4_1_pinsrd = 4313,
CODE_FOR_sse4_1_pinsrq = 4314,
CODE_FOR_avx512dq_vinsertf64x2_1_mask = 4320,
CODE_FOR_avx512dq_vinserti64x2_1_mask = 4322,
CODE_FOR_avx512f_vinsertf32x4_1_mask = 4324,
CODE_FOR_avx512f_vinserti32x4_1_mask = 4326,
CODE_FOR_vec_set_lo_v16sf = 4327,
CODE_FOR_vec_set_lo_v16sf_mask = 4328,
CODE_FOR_vec_set_lo_v16si = 4329,
CODE_FOR_vec_set_lo_v16si_mask = 4330,
CODE_FOR_vec_set_hi_v16sf = 4331,
CODE_FOR_vec_set_hi_v16sf_mask = 4332,
CODE_FOR_vec_set_hi_v16si = 4333,
CODE_FOR_vec_set_hi_v16si_mask = 4334,
CODE_FOR_vec_set_lo_v8df = 4335,
CODE_FOR_vec_set_lo_v8df_mask = 4336,
CODE_FOR_vec_set_lo_v8di = 4337,
CODE_FOR_vec_set_lo_v8di_mask = 4338,
CODE_FOR_vec_set_hi_v8df = 4339,
CODE_FOR_vec_set_hi_v8df_mask = 4340,
CODE_FOR_vec_set_hi_v8di = 4341,
CODE_FOR_vec_set_hi_v8di_mask = 4342,
CODE_FOR_avx512dq_shuf_i64x2_1_mask = 4344,
CODE_FOR_avx512dq_shuf_f64x2_1_mask = 4346,
CODE_FOR_avx512f_shuf_f64x2_1 = 4347,
CODE_FOR_avx512f_shuf_f64x2_1_mask = 4348,
CODE_FOR_avx512f_shuf_i64x2_1 = 4349,
CODE_FOR_avx512f_shuf_i64x2_1_mask = 4350,
CODE_FOR_avx512vl_shuf_i32x4_1 = 4351,
CODE_FOR_avx512vl_shuf_i32x4_1_mask = 4352,
CODE_FOR_avx512vl_shuf_f32x4_1 = 4353,
CODE_FOR_avx512vl_shuf_f32x4_1_mask = 4354,
CODE_FOR_avx512f_shuf_f32x4_1 = 4355,
CODE_FOR_avx512f_shuf_f32x4_1_mask = 4356,
CODE_FOR_avx512f_shuf_i32x4_1 = 4357,
CODE_FOR_avx512f_shuf_i32x4_1_mask = 4358,
CODE_FOR_avx512f_pshufd_1 = 4359,
CODE_FOR_avx512f_pshufd_1_mask = 4360,
CODE_FOR_avx2_pshufd_1 = 4361,
CODE_FOR_avx2_pshufd_1_mask = 4362,
CODE_FOR_sse2_pshufd_1 = 4363,
CODE_FOR_sse2_pshufd_1_mask = 4364,
CODE_FOR_avx512bw_pshuflwv32hi_mask = 4366,
CODE_FOR_avx2_pshuflw_1 = 4367,
CODE_FOR_avx2_pshuflw_1_mask = 4368,
CODE_FOR_sse2_pshuflw_1 = 4369,
CODE_FOR_sse2_pshuflw_1_mask = 4370,
CODE_FOR_avx512bw_pshufhwv32hi_mask = 4372,
CODE_FOR_avx2_pshufhw_1 = 4373,
CODE_FOR_avx2_pshufhw_1_mask = 4374,
CODE_FOR_sse2_pshufhw_1 = 4375,
CODE_FOR_sse2_pshufhw_1_mask = 4376,
CODE_FOR_sse2_loadld = 4377,
CODE_FOR_vec_concatv2di = 4403,
CODE_FOR_vec_setv8di_0 = 4405,
CODE_FOR_vec_setv4di_0 = 4406,
CODE_FOR_avx512f_psadbw = 4419,
CODE_FOR_avx2_psadbw = 4420,
CODE_FOR_sse2_psadbw = 4421,
CODE_FOR_avx_movmskps256 = 4422,
CODE_FOR_sse_movmskps = 4423,
CODE_FOR_avx_movmskpd256 = 4424,
CODE_FOR_sse2_movmskpd = 4425,
CODE_FOR_avx2_pmovmskb = 4458,
CODE_FOR_sse2_pmovmskb = 4459,
CODE_FOR_sse_ldmxcsr = 4470,
CODE_FOR_sse_stmxcsr = 4471,
CODE_FOR_sse2_clflush = 4472,
CODE_FOR_sse3_mwait = 4473,
CODE_FOR_sse3_monitor_si = 4474,
CODE_FOR_sse3_monitor_di = 4475,
CODE_FOR_avx2_phaddwv16hi3 = 4476,
CODE_FOR_avx2_phaddswv16hi3 = 4477,
CODE_FOR_avx2_phsubwv16hi3 = 4478,
CODE_FOR_avx2_phsubswv16hi3 = 4479,
CODE_FOR_ssse3_phaddwv8hi3 = 4480,
CODE_FOR_ssse3_phaddswv8hi3 = 4481,
CODE_FOR_ssse3_phsubwv8hi3 = 4482,
CODE_FOR_ssse3_phsubswv8hi3 = 4483,
CODE_FOR_ssse3_phaddwv4hi3 = 4484,
CODE_FOR_ssse3_phaddswv4hi3 = 4485,
CODE_FOR_ssse3_phsubwv4hi3 = 4486,
CODE_FOR_ssse3_phsubswv4hi3 = 4487,
CODE_FOR_avx2_phadddv8si3 = 4488,
CODE_FOR_avx2_phsubdv8si3 = 4489,
CODE_FOR_ssse3_phadddv4si3 = 4490,
CODE_FOR_ssse3_phsubdv4si3 = 4491,
CODE_FOR_ssse3_phadddv2si3 = 4492,
CODE_FOR_ssse3_phsubdv2si3 = 4493,
CODE_FOR_avx2_pmaddubsw256 = 4494,
CODE_FOR_avx512bw_pmaddubsw512v8hi = 4495,
CODE_FOR_avx512bw_pmaddubsw512v8hi_mask = 4496,
CODE_FOR_avx512bw_pmaddubsw512v16hi = 4497,
CODE_FOR_avx512bw_pmaddubsw512v16hi_mask = 4498,
CODE_FOR_avx512bw_pmaddubsw512v32hi = 4499,
CODE_FOR_avx512bw_pmaddubsw512v32hi_mask = 4500,
CODE_FOR_avx512bw_umulhrswv32hi3 = 4501,
CODE_FOR_avx512bw_umulhrswv32hi3_mask = 4502,
CODE_FOR_ssse3_pmaddubsw128 = 4503,
CODE_FOR_ssse3_pmaddubsw = 4504,
CODE_FOR_avx512bw_pshufbv64qi3 = 4512,
CODE_FOR_avx512bw_pshufbv64qi3_mask = 4513,
CODE_FOR_avx2_pshufbv32qi3 = 4514,
CODE_FOR_avx2_pshufbv32qi3_mask = 4515,
CODE_FOR_ssse3_pshufbv16qi3 = 4516,
CODE_FOR_ssse3_pshufbv16qi3_mask = 4517,
CODE_FOR_ssse3_pshufbv8qi3 = 4518,
CODE_FOR_avx2_psignv32qi3 = 4519,
CODE_FOR_ssse3_psignv16qi3 = 4520,
CODE_FOR_avx2_psignv16hi3 = 4521,
CODE_FOR_ssse3_psignv8hi3 = 4522,
CODE_FOR_avx2_psignv8si3 = 4523,
CODE_FOR_ssse3_psignv4si3 = 4524,
CODE_FOR_ssse3_psignv8qi3 = 4525,
CODE_FOR_ssse3_psignv4hi3 = 4526,
CODE_FOR_ssse3_psignv2si3 = 4527,
CODE_FOR_avx512bw_palignrv64qi_mask = 4528,
CODE_FOR_avx2_palignrv32qi_mask = 4529,
CODE_FOR_ssse3_palignrv16qi_mask = 4530,
CODE_FOR_avx512bw_palignrv4ti = 4531,
CODE_FOR_avx2_palignrv2ti = 4532,
CODE_FOR_ssse3_palignrti = 4533,
CODE_FOR_ssse3_palignrdi = 4534,
CODE_FOR_absv16si2_mask = 4547,
CODE_FOR_absv8si2_mask = 4548,
CODE_FOR_absv4si2_mask = 4549,
CODE_FOR_absv8di2_mask = 4550,
CODE_FOR_absv4di2_mask = 4551,
CODE_FOR_absv2di2_mask = 4552,
CODE_FOR_absv64qi2_mask = 4553,
CODE_FOR_absv16qi2_mask = 4554,
CODE_FOR_absv32qi2_mask = 4555,
CODE_FOR_absv32hi2_mask = 4556,
CODE_FOR_absv16hi2_mask = 4557,
CODE_FOR_absv8hi2_mask = 4558,
CODE_FOR_ssse3_absv8qi2 = 4559,
CODE_FOR_ssse3_absv4hi2 = 4560,
CODE_FOR_ssse3_absv2si2 = 4561,
CODE_FOR_absv8qi2 = 4562,
CODE_FOR_absv4hi2 = 4563,
CODE_FOR_absv2si2 = 4564,
CODE_FOR_sse4a_movntsf = 4565,
CODE_FOR_sse4a_movntdf = 4566,
CODE_FOR_sse4a_vmmovntv4sf = 4567,
CODE_FOR_sse4a_vmmovntv2df = 4568,
CODE_FOR_sse4a_extrqi = 4569,
CODE_FOR_sse4a_extrq = 4570,
CODE_FOR_sse4a_insertqi = 4571,
CODE_FOR_sse4a_insertq = 4572,
CODE_FOR_avx_blendps256 = 4573,
CODE_FOR_sse4_1_blendps = 4574,
CODE_FOR_avx_blendpd256 = 4575,
CODE_FOR_sse4_1_blendpd = 4576,
CODE_FOR_avx_blendvps256 = 4577,
CODE_FOR_sse4_1_blendvps = 4578,
CODE_FOR_avx_blendvpd256 = 4579,
CODE_FOR_sse4_1_blendvpd = 4580,
CODE_FOR_sse4_1_blendvss = 4581,
CODE_FOR_sse4_1_blendvsd = 4582,
CODE_FOR_avx_dpps256 = 4591,
CODE_FOR_sse4_1_dpps = 4592,
CODE_FOR_avx_dppd256 = 4593,
CODE_FOR_sse4_1_dppd = 4594,
CODE_FOR_avx512f_movntdqa = 4595,
CODE_FOR_avx2_movntdqa = 4596,
CODE_FOR_sse4_1_movntdqa = 4597,
CODE_FOR_avx2_mpsadbw = 4598,
CODE_FOR_sse4_1_mpsadbw = 4599,
CODE_FOR_avx512bw_packusdw = 4600,
CODE_FOR_avx512bw_packusdw_mask = 4601,
CODE_FOR_avx2_packusdw = 4602,
CODE_FOR_avx2_packusdw_mask = 4603,
CODE_FOR_sse4_1_packusdw = 4604,
CODE_FOR_sse4_1_packusdw_mask = 4605,
CODE_FOR_avx2_pblendvb = 4606,
CODE_FOR_sse4_1_pblendvb = 4607,
CODE_FOR_sse4_1_pblendw = 4610,
CODE_FOR_avx2_pblenddv8si = 4612,
CODE_FOR_avx2_pblenddv4si = 4613,
CODE_FOR_sse4_1_phminposuw = 4614,
CODE_FOR_avx2_sign_extendv16qiv16hi2 = 4615,
CODE_FOR_avx2_sign_extendv16qiv16hi2_mask = 4616,
CODE_FOR_avx2_zero_extendv16qiv16hi2 = 4617,
CODE_FOR_avx2_zero_extendv16qiv16hi2_mask = 4618,
CODE_FOR_avx512bw_sign_extendv32qiv32hi2 = 4619,
CODE_FOR_avx512bw_sign_extendv32qiv32hi2_mask = 4620,
CODE_FOR_avx512bw_zero_extendv32qiv32hi2 = 4621,
CODE_FOR_avx512bw_zero_extendv32qiv32hi2_mask = 4622,
CODE_FOR_sse4_1_sign_extendv8qiv8hi2 = 4623,
CODE_FOR_sse4_1_sign_extendv8qiv8hi2_mask = 4624,
CODE_FOR_sse4_1_zero_extendv8qiv8hi2 = 4625,
CODE_FOR_sse4_1_zero_extendv8qiv8hi2_mask = 4626,
CODE_FOR_avx512f_sign_extendv16qiv16si2_mask = 4636,
CODE_FOR_avx512f_zero_extendv16qiv16si2_mask = 4638,
CODE_FOR_avx2_sign_extendv8qiv8si2 = 4639,
CODE_FOR_avx2_sign_extendv8qiv8si2_mask = 4640,
CODE_FOR_avx2_zero_extendv8qiv8si2 = 4641,
CODE_FOR_avx2_zero_extendv8qiv8si2_mask = 4642,
CODE_FOR_sse4_1_sign_extendv4qiv4si2 = 4651,
CODE_FOR_sse4_1_sign_extendv4qiv4si2_mask = 4652,
CODE_FOR_sse4_1_zero_extendv4qiv4si2 = 4653,
CODE_FOR_sse4_1_zero_extendv4qiv4si2_mask = 4654,
CODE_FOR_avx512f_sign_extendv16hiv16si2 = 4663,
CODE_FOR_avx512f_sign_extendv16hiv16si2_mask = 4664,
CODE_FOR_avx512f_zero_extendv16hiv16si2 = 4665,
CODE_FOR_avx512f_zero_extendv16hiv16si2_mask = 4666,
CODE_FOR_avx2_sign_extendv8hiv8si2 = 4667,
CODE_FOR_avx2_sign_extendv8hiv8si2_mask = 4668,
CODE_FOR_avx2_zero_extendv8hiv8si2 = 4669,
CODE_FOR_avx2_zero_extendv8hiv8si2_mask = 4670,
CODE_FOR_sse4_1_sign_extendv4hiv4si2 = 4671,
CODE_FOR_sse4_1_sign_extendv4hiv4si2_mask = 4672,
CODE_FOR_sse4_1_zero_extendv4hiv4si2 = 4673,
CODE_FOR_sse4_1_zero_extendv4hiv4si2_mask = 4674,
CODE_FOR_avx512f_sign_extendv8qiv8di2 = 4683,
CODE_FOR_avx512f_sign_extendv8qiv8di2_mask = 4684,
CODE_FOR_avx512f_zero_extendv8qiv8di2 = 4685,
CODE_FOR_avx512f_zero_extendv8qiv8di2_mask = 4686,
CODE_FOR_avx2_sign_extendv4qiv4di2 = 4695,
CODE_FOR_avx2_sign_extendv4qiv4di2_mask = 4696,
CODE_FOR_avx2_zero_extendv4qiv4di2 = 4697,
CODE_FOR_avx2_zero_extendv4qiv4di2_mask = 4698,
CODE_FOR_sse4_1_sign_extendv2qiv2di2 = 4707,
CODE_FOR_sse4_1_sign_extendv2qiv2di2_mask = 4708,
CODE_FOR_sse4_1_zero_extendv2qiv2di2 = 4709,
CODE_FOR_sse4_1_zero_extendv2qiv2di2_mask = 4710,
CODE_FOR_avx512f_sign_extendv8hiv8di2 = 4711,
CODE_FOR_avx512f_sign_extendv8hiv8di2_mask = 4712,
CODE_FOR_avx512f_zero_extendv8hiv8di2 = 4713,
CODE_FOR_avx512f_zero_extendv8hiv8di2_mask = 4714,
CODE_FOR_avx2_sign_extendv4hiv4di2 = 4715,
CODE_FOR_avx2_sign_extendv4hiv4di2_mask = 4716,
CODE_FOR_avx2_zero_extendv4hiv4di2 = 4717,
CODE_FOR_avx2_zero_extendv4hiv4di2_mask = 4718,
CODE_FOR_sse4_1_sign_extendv2hiv2di2 = 4727,
CODE_FOR_sse4_1_sign_extendv2hiv2di2_mask = 4728,
CODE_FOR_sse4_1_zero_extendv2hiv2di2 = 4729,
CODE_FOR_sse4_1_zero_extendv2hiv2di2_mask = 4730,
CODE_FOR_avx512f_sign_extendv8siv8di2 = 4739,
CODE_FOR_avx512f_sign_extendv8siv8di2_mask = 4740,
CODE_FOR_avx512f_zero_extendv8siv8di2 = 4741,
CODE_FOR_avx512f_zero_extendv8siv8di2_mask = 4742,
CODE_FOR_avx2_sign_extendv4siv4di2 = 4743,
CODE_FOR_avx2_sign_extendv4siv4di2_mask = 4744,
CODE_FOR_avx2_zero_extendv4siv4di2 = 4745,
CODE_FOR_avx2_zero_extendv4siv4di2_mask = 4746,
CODE_FOR_sse4_1_sign_extendv2siv2di2 = 4747,
CODE_FOR_sse4_1_sign_extendv2siv2di2_mask = 4748,
CODE_FOR_sse4_1_zero_extendv2siv2di2 = 4749,
CODE_FOR_sse4_1_zero_extendv2siv2di2_mask = 4750,
CODE_FOR_avx_vtestps256 = 4759,
CODE_FOR_avx_vtestps = 4760,
CODE_FOR_avx_vtestpd256 = 4761,
CODE_FOR_avx_vtestpd = 4762,
CODE_FOR_sse4_1_ptestv16qi = 4763,
CODE_FOR_sse4_1_ptestv8hi = 4764,
CODE_FOR_sse4_1_ptestv4si = 4765,
CODE_FOR_sse4_1_ptestv2di = 4766,
CODE_FOR_sse4_1_ptestv4sf = 4767,
CODE_FOR_sse4_1_ptestv2df = 4768,
CODE_FOR_avx_ptestv32qi = 4769,
CODE_FOR_avx_ptestv16hi = 4770,
CODE_FOR_avx_ptestv8si = 4771,
CODE_FOR_avx_ptestv4di = 4772,
CODE_FOR_avx_ptestv8sf = 4773,
CODE_FOR_avx_ptestv4df = 4774,
CODE_FOR_ptesttf2 = 4775,
CODE_FOR_avx_roundps256 = 4776,
CODE_FOR_sse4_1_roundps = 4777,
CODE_FOR_avx_roundpd256 = 4778,
CODE_FOR_sse4_1_roundpd = 4779,
CODE_FOR_sse4_1_roundss = 4780,
CODE_FOR_sse4_1_roundsd = 4781,
CODE_FOR_sse4_2_pcmpestr = 4784,
CODE_FOR_sse4_2_pcmpestri = 4785,
CODE_FOR_sse4_2_pcmpestrm = 4786,
CODE_FOR_sse4_2_pcmpestr_cconly = 4787,
CODE_FOR_sse4_2_pcmpistr = 4788,
CODE_FOR_sse4_2_pcmpistri = 4789,
CODE_FOR_sse4_2_pcmpistrm = 4790,
CODE_FOR_sse4_2_pcmpistr_cconly = 4791,
CODE_FOR_avx512er_exp2v16sf = 4808,
CODE_FOR_avx512er_exp2v16sf_round = 4809,
CODE_FOR_avx512er_exp2v16sf_mask = 4810,
CODE_FOR_avx512er_exp2v16sf_mask_round = 4811,
CODE_FOR_avx512er_exp2v8df = 4812,
CODE_FOR_avx512er_exp2v8df_round = 4813,
CODE_FOR_avx512er_exp2v8df_mask = 4814,
CODE_FOR_avx512er_exp2v8df_mask_round = 4815,
CODE_FOR_avx512er_rcp28v16sf_mask = 4818,
CODE_FOR_avx512er_rcp28v16sf_mask_round = 4819,
CODE_FOR_avx512er_rcp28v8df_mask = 4822,
CODE_FOR_avx512er_rcp28v8df_mask_round = 4823,
CODE_FOR_avx512er_vmrcp28v4sf = 4824,
CODE_FOR_avx512er_vmrcp28v4sf_round = 4825,
CODE_FOR_avx512er_vmrcp28v2df = 4826,
CODE_FOR_avx512er_vmrcp28v2df_round = 4827,
CODE_FOR_avx512er_rsqrt28v16sf_mask = 4830,
CODE_FOR_avx512er_rsqrt28v16sf_mask_round = 4831,
CODE_FOR_avx512er_rsqrt28v8df_mask = 4834,
CODE_FOR_avx512er_rsqrt28v8df_mask_round = 4835,
CODE_FOR_avx512er_vmrsqrt28v4sf = 4836,
CODE_FOR_avx512er_vmrsqrt28v4sf_round = 4837,
CODE_FOR_avx512er_vmrsqrt28v2df = 4838,
CODE_FOR_avx512er_vmrsqrt28v2df_round = 4839,
CODE_FOR_xop_pmacsww = 4840,
CODE_FOR_xop_pmacssww = 4841,
CODE_FOR_xop_pmacsdd = 4842,
CODE_FOR_xop_pmacssdd = 4843,
CODE_FOR_xop_pmacsdql = 4844,
CODE_FOR_xop_pmacssdql = 4845,
CODE_FOR_xop_pmacsdqh = 4846,
CODE_FOR_xop_pmacssdqh = 4847,
CODE_FOR_xop_pmacswd = 4848,
CODE_FOR_xop_pmacsswd = 4849,
CODE_FOR_xop_pmadcswd = 4850,
CODE_FOR_xop_pmadcsswd = 4851,
CODE_FOR_xop_pcmov_v32qi256 = 4852,
CODE_FOR_xop_pcmov_v16qi = 4853,
CODE_FOR_xop_pcmov_v16hi256 = 4854,
CODE_FOR_xop_pcmov_v8hi = 4855,
CODE_FOR_xop_pcmov_v8si256 = 4856,
CODE_FOR_xop_pcmov_v4si = 4857,
CODE_FOR_xop_pcmov_v4di256 = 4858,
CODE_FOR_xop_pcmov_v2di = 4859,
CODE_FOR_xop_pcmov_v8sf256 = 4860,
CODE_FOR_xop_pcmov_v4sf = 4861,
CODE_FOR_xop_pcmov_v4df256 = 4862,
CODE_FOR_xop_pcmov_v2df = 4863,
CODE_FOR_xop_phaddbw = 4864,
CODE_FOR_xop_phaddubw = 4865,
CODE_FOR_xop_phaddbd = 4866,
CODE_FOR_xop_phaddubd = 4867,
CODE_FOR_xop_phaddbq = 4868,
CODE_FOR_xop_phaddubq = 4869,
CODE_FOR_xop_phaddwd = 4870,
CODE_FOR_xop_phadduwd = 4871,
CODE_FOR_xop_phaddwq = 4872,
CODE_FOR_xop_phadduwq = 4873,
CODE_FOR_xop_phadddq = 4874,
CODE_FOR_xop_phaddudq = 4875,
CODE_FOR_xop_phsubbw = 4876,
CODE_FOR_xop_phsubwd = 4877,
CODE_FOR_xop_phsubdq = 4878,
CODE_FOR_xop_pperm = 4879,
CODE_FOR_xop_pperm_pack_v2di_v4si = 4880,
CODE_FOR_xop_pperm_pack_v4si_v8hi = 4881,
CODE_FOR_xop_pperm_pack_v8hi_v16qi = 4882,
CODE_FOR_xop_rotlv16qi3 = 4883,
CODE_FOR_xop_rotlv8hi3 = 4884,
CODE_FOR_xop_rotlv4si3 = 4885,
CODE_FOR_xop_rotlv2di3 = 4886,
CODE_FOR_xop_rotrv16qi3 = 4887,
CODE_FOR_xop_rotrv8hi3 = 4888,
CODE_FOR_xop_rotrv4si3 = 4889,
CODE_FOR_xop_rotrv2di3 = 4890,
CODE_FOR_xop_vrotlv16qi3 = 4891,
CODE_FOR_xop_vrotlv8hi3 = 4892,
CODE_FOR_xop_vrotlv4si3 = 4893,
CODE_FOR_xop_vrotlv2di3 = 4894,
CODE_FOR_xop_shav16qi3 = 4895,
CODE_FOR_xop_shav8hi3 = 4896,
CODE_FOR_xop_shav4si3 = 4897,
CODE_FOR_xop_shav2di3 = 4898,
CODE_FOR_xop_shlv16qi3 = 4899,
CODE_FOR_xop_shlv8hi3 = 4900,
CODE_FOR_xop_shlv4si3 = 4901,
CODE_FOR_xop_shlv2di3 = 4902,
CODE_FOR_xop_frczsf2 = 4903,
CODE_FOR_xop_frczdf2 = 4904,
CODE_FOR_xop_frczv4sf2 = 4905,
CODE_FOR_xop_frczv2df2 = 4906,
CODE_FOR_xop_frczv8sf2 = 4907,
CODE_FOR_xop_frczv4df2 = 4908,
CODE_FOR_xop_maskcmpv16qi3 = 4911,
CODE_FOR_xop_maskcmpv8hi3 = 4912,
CODE_FOR_xop_maskcmpv4si3 = 4913,
CODE_FOR_xop_maskcmpv2di3 = 4914,
CODE_FOR_xop_maskcmp_unsv16qi3 = 4915,
CODE_FOR_xop_maskcmp_unsv8hi3 = 4916,
CODE_FOR_xop_maskcmp_unsv4si3 = 4917,
CODE_FOR_xop_maskcmp_unsv2di3 = 4918,
CODE_FOR_xop_maskcmp_uns2v16qi3 = 4919,
CODE_FOR_xop_maskcmp_uns2v8hi3 = 4920,
CODE_FOR_xop_maskcmp_uns2v4si3 = 4921,
CODE_FOR_xop_maskcmp_uns2v2di3 = 4922,
CODE_FOR_xop_pcom_tfv16qi3 = 4923,
CODE_FOR_xop_pcom_tfv8hi3 = 4924,
CODE_FOR_xop_pcom_tfv4si3 = 4925,
CODE_FOR_xop_pcom_tfv2di3 = 4926,
CODE_FOR_xop_vpermil2v8sf3 = 4927,
CODE_FOR_xop_vpermil2v4sf3 = 4928,
CODE_FOR_xop_vpermil2v4df3 = 4929,
CODE_FOR_xop_vpermil2v2df3 = 4930,
CODE_FOR_aesenc = 4931,
CODE_FOR_aesenclast = 4932,
CODE_FOR_aesdec = 4933,
CODE_FOR_aesdeclast = 4934,
CODE_FOR_aesimc = 4935,
CODE_FOR_aeskeygenassist = 4936,
CODE_FOR_pclmulqdq = 4937,
CODE_FOR_avx2_pbroadcastv16si = 4941,
CODE_FOR_avx2_pbroadcastv8di = 4942,
CODE_FOR_avx2_pbroadcastv64qi = 4943,
CODE_FOR_avx2_pbroadcastv32qi = 4944,
CODE_FOR_avx2_pbroadcastv16qi = 4945,
CODE_FOR_avx2_pbroadcastv32hi = 4946,
CODE_FOR_avx2_pbroadcastv16hi = 4947,
CODE_FOR_avx2_pbroadcastv8hi = 4948,
CODE_FOR_avx2_pbroadcastv8si = 4949,
CODE_FOR_avx2_pbroadcastv4si = 4950,
CODE_FOR_avx2_pbroadcastv4di = 4951,
CODE_FOR_avx2_pbroadcastv2di = 4952,
CODE_FOR_avx2_pbroadcastv32qi_1 = 4953,
CODE_FOR_avx2_pbroadcastv16hi_1 = 4954,
CODE_FOR_avx2_pbroadcastv8si_1 = 4955,
CODE_FOR_avx2_pbroadcastv4di_1 = 4956,
CODE_FOR_avx2_permvarv8si = 4957,
CODE_FOR_avx2_permvarv8si_mask = 4958,
CODE_FOR_avx2_permvarv8sf = 4959,
CODE_FOR_avx2_permvarv8sf_mask = 4960,
CODE_FOR_avx512f_permvarv16si = 4961,
CODE_FOR_avx512f_permvarv16si_mask = 4962,
CODE_FOR_avx512f_permvarv16sf = 4963,
CODE_FOR_avx512f_permvarv16sf_mask = 4964,
CODE_FOR_avx512f_permvarv8di = 4965,
CODE_FOR_avx512f_permvarv8di_mask = 4966,
CODE_FOR_avx512f_permvarv8df = 4967,
CODE_FOR_avx512f_permvarv8df_mask = 4968,
CODE_FOR_avx2_permvarv4di = 4969,
CODE_FOR_avx2_permvarv4di_mask = 4970,
CODE_FOR_avx2_permvarv4df = 4971,
CODE_FOR_avx2_permvarv4df_mask = 4972,
CODE_FOR_avx512bw_permvarv64qi = 4973,
CODE_FOR_avx512bw_permvarv64qi_mask = 4974,
CODE_FOR_avx512vl_permvarv16qi = 4975,
CODE_FOR_avx512vl_permvarv16qi_mask = 4976,
CODE_FOR_avx512vl_permvarv32qi = 4977,
CODE_FOR_avx512vl_permvarv32qi_mask = 4978,
CODE_FOR_avx512vl_permvarv8hi = 4979,
CODE_FOR_avx512vl_permvarv8hi_mask = 4980,
CODE_FOR_avx512vl_permvarv16hi = 4981,
CODE_FOR_avx512vl_permvarv16hi_mask = 4982,
CODE_FOR_avx512bw_permvarv32hi = 4983,
CODE_FOR_avx512bw_permvarv32hi_mask = 4984,
CODE_FOR_avx2_permv4di_1 = 5000,
CODE_FOR_avx2_permv4di_1_mask = 5001,
CODE_FOR_avx2_permv4df_1 = 5002,
CODE_FOR_avx2_permv4df_1_mask = 5003,
CODE_FOR_avx512f_permv8df_1 = 5004,
CODE_FOR_avx512f_permv8df_1_mask = 5005,
CODE_FOR_avx512f_permv8di_1 = 5006,
CODE_FOR_avx512f_permv8di_1_mask = 5007,
CODE_FOR_avx2_permv2ti = 5008,
CODE_FOR_avx2_vec_dupv4df = 5009,
CODE_FOR_avx512f_vec_dupv16si_1 = 5010,
CODE_FOR_avx512f_vec_dupv8di_1 = 5011,
CODE_FOR_avx512bw_vec_dupv32hi_1 = 5012,
CODE_FOR_avx512bw_vec_dupv64qi_1 = 5013,
CODE_FOR_avx512f_vec_dupv16si = 5014,
CODE_FOR_avx512f_vec_dupv16si_mask = 5015,
CODE_FOR_avx512vl_vec_dupv8si = 5016,
CODE_FOR_avx512vl_vec_dupv8si_mask = 5017,
CODE_FOR_avx512vl_vec_dupv4si = 5018,
CODE_FOR_avx512vl_vec_dupv4si_mask = 5019,
CODE_FOR_avx512f_vec_dupv8di = 5020,
CODE_FOR_avx512f_vec_dupv8di_mask = 5021,
CODE_FOR_avx512vl_vec_dupv4di = 5022,
CODE_FOR_avx512vl_vec_dupv4di_mask = 5023,
CODE_FOR_avx512vl_vec_dupv2di = 5024,
CODE_FOR_avx512vl_vec_dupv2di_mask = 5025,
CODE_FOR_avx512f_vec_dupv16sf = 5026,
CODE_FOR_avx512f_vec_dupv16sf_mask = 5027,
CODE_FOR_avx512vl_vec_dupv8sf = 5028,
CODE_FOR_avx512vl_vec_dupv8sf_mask = 5029,
CODE_FOR_avx512vl_vec_dupv4sf = 5030,
CODE_FOR_avx512vl_vec_dupv4sf_mask = 5031,
CODE_FOR_avx512f_vec_dupv8df = 5032,
CODE_FOR_avx512f_vec_dupv8df_mask = 5033,
CODE_FOR_avx512vl_vec_dupv4df = 5034,
CODE_FOR_avx512vl_vec_dupv4df_mask = 5035,
CODE_FOR_avx512vl_vec_dupv2df = 5036,
CODE_FOR_avx512vl_vec_dupv2df_mask = 5037,
CODE_FOR_avx512bw_vec_dupv64qi = 5038,
CODE_FOR_avx512bw_vec_dupv64qi_mask = 5039,
CODE_FOR_avx512vl_vec_dupv16qi = 5040,
CODE_FOR_avx512vl_vec_dupv16qi_mask = 5041,
CODE_FOR_avx512vl_vec_dupv32qi = 5042,
CODE_FOR_avx512vl_vec_dupv32qi_mask = 5043,
CODE_FOR_avx512bw_vec_dupv32hi = 5044,
CODE_FOR_avx512bw_vec_dupv32hi_mask = 5045,
CODE_FOR_avx512vl_vec_dupv16hi = 5046,
CODE_FOR_avx512vl_vec_dupv16hi_mask = 5047,
CODE_FOR_avx512vl_vec_dupv8hi = 5048,
CODE_FOR_avx512vl_vec_dupv8hi_mask = 5049,
CODE_FOR_avx512f_broadcastv16sf_mask = 5051,
CODE_FOR_avx512f_broadcastv16si_mask = 5053,
CODE_FOR_avx512f_broadcastv8df_mask = 5055,
CODE_FOR_avx512f_broadcastv8di_mask = 5057,
CODE_FOR_avx512bw_vec_dup_gprv64qi_mask = 5059,
CODE_FOR_avx512vl_vec_dup_gprv16qi_mask = 5061,
CODE_FOR_avx512vl_vec_dup_gprv32qi_mask = 5063,
CODE_FOR_avx512bw_vec_dup_gprv32hi_mask = 5065,
CODE_FOR_avx512vl_vec_dup_gprv16hi_mask = 5067,
CODE_FOR_avx512vl_vec_dup_gprv8hi_mask = 5069,
CODE_FOR_avx512f_vec_dup_gprv16si_mask = 5071,
CODE_FOR_avx512vl_vec_dup_gprv8si_mask = 5073,
CODE_FOR_avx512vl_vec_dup_gprv4si_mask = 5075,
CODE_FOR_avx512f_vec_dup_gprv8di_mask = 5077,
CODE_FOR_avx512vl_vec_dup_gprv4di_mask = 5079,
CODE_FOR_avx512vl_vec_dup_gprv2di_mask = 5081,
CODE_FOR_avx512f_vec_dup_gprv16sf_mask = 5083,
CODE_FOR_avx512vl_vec_dup_gprv8sf_mask = 5085,
CODE_FOR_avx512vl_vec_dup_gprv4sf_mask = 5087,
CODE_FOR_avx512f_vec_dup_gprv8df_mask = 5089,
CODE_FOR_avx512vl_vec_dup_gprv4df_mask = 5091,
CODE_FOR_avx512vl_vec_dup_gprv2df_mask = 5093,
CODE_FOR_vec_dupv4sf = 5094,
CODE_FOR_avx2_vbroadcasti128_v32qi = 5097,
CODE_FOR_avx2_vbroadcasti128_v16hi = 5098,
CODE_FOR_avx2_vbroadcasti128_v8si = 5099,
CODE_FOR_avx2_vbroadcasti128_v4di = 5100,
CODE_FOR_vec_dupv8si = 5107,
CODE_FOR_vec_dupv8sf = 5108,
CODE_FOR_vec_dupv4di = 5109,
CODE_FOR_vec_dupv4df = 5110,
CODE_FOR_avx_vbroadcastf128_v32qi = 5111,
CODE_FOR_avx_vbroadcastf128_v16hi = 5112,
CODE_FOR_avx_vbroadcastf128_v8si = 5113,
CODE_FOR_avx_vbroadcastf128_v4di = 5114,
CODE_FOR_avx_vbroadcastf128_v8sf = 5115,
CODE_FOR_avx_vbroadcastf128_v4df = 5116,
CODE_FOR_avx512dq_broadcastv16si_mask = 5118,
CODE_FOR_avx512dq_broadcastv8si_mask = 5120,
CODE_FOR_avx512dq_broadcastv4si_mask = 5122,
CODE_FOR_avx512dq_broadcastv16sf_mask = 5124,
CODE_FOR_avx512dq_broadcastv8sf_mask = 5126,
CODE_FOR_avx512vl_broadcastv8si_mask_1 = 5128,
CODE_FOR_avx512vl_broadcastv8sf_mask_1 = 5130,
CODE_FOR_avx512dq_broadcastv16sf_mask_1 = 5132,
CODE_FOR_avx512dq_broadcastv16si_mask_1 = 5134,
CODE_FOR_avx512dq_broadcastv8di_mask_1 = 5136,
CODE_FOR_avx512dq_broadcastv8df_mask_1 = 5138,
CODE_FOR_avx512dq_broadcastv4di_mask_1 = 5140,
CODE_FOR_avx512dq_broadcastv4df_mask_1 = 5142,
CODE_FOR_avx512cd_maskb_vec_dupv8di = 5143,
CODE_FOR_avx512cd_maskb_vec_dupv4di = 5144,
CODE_FOR_avx512cd_maskb_vec_dupv2di = 5145,
CODE_FOR_avx512cd_maskw_vec_dupv16si = 5146,
CODE_FOR_avx512cd_maskw_vec_dupv8si = 5147,
CODE_FOR_avx512cd_maskw_vec_dupv4si = 5148,
CODE_FOR_avx512f_vpermilvarv16sf3 = 5149,
CODE_FOR_avx512f_vpermilvarv16sf3_mask = 5150,
CODE_FOR_avx_vpermilvarv8sf3 = 5151,
CODE_FOR_avx_vpermilvarv8sf3_mask = 5152,
CODE_FOR_avx_vpermilvarv4sf3 = 5153,
CODE_FOR_avx_vpermilvarv4sf3_mask = 5154,
CODE_FOR_avx512f_vpermilvarv8df3 = 5155,
CODE_FOR_avx512f_vpermilvarv8df3_mask = 5156,
CODE_FOR_avx_vpermilvarv4df3 = 5157,
CODE_FOR_avx_vpermilvarv4df3_mask = 5158,
CODE_FOR_avx_vpermilvarv2df3 = 5159,
CODE_FOR_avx_vpermilvarv2df3_mask = 5160,
CODE_FOR_avx512f_vpermt2varv16si3 = 5179,
CODE_FOR_avx512f_vpermt2varv16si3_maskz_1 = 5180,
CODE_FOR_avx512f_vpermt2varv16sf3 = 5181,
CODE_FOR_avx512f_vpermt2varv16sf3_maskz_1 = 5182,
CODE_FOR_avx512f_vpermt2varv8di3 = 5183,
CODE_FOR_avx512f_vpermt2varv8di3_maskz_1 = 5184,
CODE_FOR_avx512f_vpermt2varv8df3 = 5185,
CODE_FOR_avx512f_vpermt2varv8df3_maskz_1 = 5186,
CODE_FOR_avx512vl_vpermt2varv8si3 = 5187,
CODE_FOR_avx512vl_vpermt2varv8si3_maskz_1 = 5188,
CODE_FOR_avx512vl_vpermt2varv8sf3 = 5189,
CODE_FOR_avx512vl_vpermt2varv8sf3_maskz_1 = 5190,
CODE_FOR_avx512vl_vpermt2varv4di3 = 5191,
CODE_FOR_avx512vl_vpermt2varv4di3_maskz_1 = 5192,
CODE_FOR_avx512vl_vpermt2varv4df3 = 5193,
CODE_FOR_avx512vl_vpermt2varv4df3_maskz_1 = 5194,
CODE_FOR_avx512vl_vpermt2varv4si3 = 5195,
CODE_FOR_avx512vl_vpermt2varv4si3_maskz_1 = 5196,
CODE_FOR_avx512vl_vpermt2varv4sf3 = 5197,
CODE_FOR_avx512vl_vpermt2varv4sf3_maskz_1 = 5198,
CODE_FOR_avx512vl_vpermt2varv2di3 = 5199,
CODE_FOR_avx512vl_vpermt2varv2di3_maskz_1 = 5200,
CODE_FOR_avx512vl_vpermt2varv2df3 = 5201,
CODE_FOR_avx512vl_vpermt2varv2df3_maskz_1 = 5202,
CODE_FOR_avx512bw_vpermt2varv32hi3 = 5203,
CODE_FOR_avx512bw_vpermt2varv32hi3_maskz_1 = 5204,
CODE_FOR_avx512vl_vpermt2varv16hi3 = 5205,
CODE_FOR_avx512vl_vpermt2varv16hi3_maskz_1 = 5206,
CODE_FOR_avx512vl_vpermt2varv8hi3 = 5207,
CODE_FOR_avx512vl_vpermt2varv8hi3_maskz_1 = 5208,
CODE_FOR_avx512bw_vpermt2varv64qi3 = 5209,
CODE_FOR_avx512bw_vpermt2varv64qi3_maskz_1 = 5210,
CODE_FOR_avx512vl_vpermt2varv32qi3 = 5211,
CODE_FOR_avx512vl_vpermt2varv32qi3_maskz_1 = 5212,
CODE_FOR_avx512vl_vpermt2varv16qi3 = 5213,
CODE_FOR_avx512vl_vpermt2varv16qi3_maskz_1 = 5214,
CODE_FOR_avx512f_vpermt2varv16si3_mask = 5215,
CODE_FOR_avx512f_vpermt2varv16sf3_mask = 5216,
CODE_FOR_avx512f_vpermt2varv8di3_mask = 5217,
CODE_FOR_avx512f_vpermt2varv8df3_mask = 5218,
CODE_FOR_avx512vl_vpermt2varv8si3_mask = 5219,
CODE_FOR_avx512vl_vpermt2varv8sf3_mask = 5220,
CODE_FOR_avx512vl_vpermt2varv4di3_mask = 5221,
CODE_FOR_avx512vl_vpermt2varv4df3_mask = 5222,
CODE_FOR_avx512vl_vpermt2varv4si3_mask = 5223,
CODE_FOR_avx512vl_vpermt2varv4sf3_mask = 5224,
CODE_FOR_avx512vl_vpermt2varv2di3_mask = 5225,
CODE_FOR_avx512vl_vpermt2varv2df3_mask = 5226,
CODE_FOR_avx512bw_vpermt2varv32hi3_mask = 5227,
CODE_FOR_avx512vl_vpermt2varv16hi3_mask = 5228,
CODE_FOR_avx512vl_vpermt2varv8hi3_mask = 5229,
CODE_FOR_avx512bw_vpermt2varv64qi3_mask = 5230,
CODE_FOR_avx512vl_vpermt2varv32qi3_mask = 5231,
CODE_FOR_avx512vl_vpermt2varv16qi3_mask = 5232,
CODE_FOR_vec_set_lo_v4di = 5245,
CODE_FOR_vec_set_lo_v4di_mask = 5246,
CODE_FOR_vec_set_lo_v4df = 5247,
CODE_FOR_vec_set_lo_v4df_mask = 5248,
CODE_FOR_vec_set_hi_v4di = 5249,
CODE_FOR_vec_set_hi_v4di_mask = 5250,
CODE_FOR_vec_set_hi_v4df = 5251,
CODE_FOR_vec_set_hi_v4df_mask = 5252,
CODE_FOR_vec_set_lo_v8si = 5253,
CODE_FOR_vec_set_lo_v8si_mask = 5254,
CODE_FOR_vec_set_lo_v8sf = 5255,
CODE_FOR_vec_set_lo_v8sf_mask = 5256,
CODE_FOR_vec_set_hi_v8si = 5257,
CODE_FOR_vec_set_hi_v8si_mask = 5258,
CODE_FOR_vec_set_hi_v8sf = 5259,
CODE_FOR_vec_set_hi_v8sf_mask = 5260,
CODE_FOR_vec_set_lo_v16hi = 5261,
CODE_FOR_vec_set_hi_v16hi = 5262,
CODE_FOR_vec_set_lo_v32qi = 5263,
CODE_FOR_vec_set_hi_v32qi = 5264,
CODE_FOR_avx_maskloadps = 5265,
CODE_FOR_avx_maskloadpd = 5266,
CODE_FOR_avx_maskloadps256 = 5267,
CODE_FOR_avx_maskloadpd256 = 5268,
CODE_FOR_avx2_maskloadd = 5269,
CODE_FOR_avx2_maskloadq = 5270,
CODE_FOR_avx2_maskloadd256 = 5271,
CODE_FOR_avx2_maskloadq256 = 5272,
CODE_FOR_avx_maskstoreps = 5273,
CODE_FOR_avx_maskstorepd = 5274,
CODE_FOR_avx_maskstoreps256 = 5275,
CODE_FOR_avx_maskstorepd256 = 5276,
CODE_FOR_avx2_maskstored = 5277,
CODE_FOR_avx2_maskstoreq = 5278,
CODE_FOR_avx2_maskstored256 = 5279,
CODE_FOR_avx2_maskstoreq256 = 5280,
CODE_FOR_avx_si256_si = 5281,
CODE_FOR_avx_ps256_ps = 5282,
CODE_FOR_avx_pd256_pd = 5283,
CODE_FOR_avx2_ashrvv4si = 5284,
CODE_FOR_avx2_ashrvv4si_mask = 5285,
CODE_FOR_avx2_ashrvv8si = 5286,
CODE_FOR_avx2_ashrvv8si_mask = 5287,
CODE_FOR_avx512f_ashrvv16si = 5288,
CODE_FOR_avx512f_ashrvv16si_mask = 5289,
CODE_FOR_avx2_ashrvv2di = 5290,
CODE_FOR_avx2_ashrvv2di_mask = 5291,
CODE_FOR_avx2_ashrvv4di = 5292,
CODE_FOR_avx2_ashrvv4di_mask = 5293,
CODE_FOR_avx512f_ashrvv8di = 5294,
CODE_FOR_avx512f_ashrvv8di_mask = 5295,
CODE_FOR_avx512vl_ashrvv8hi = 5296,
CODE_FOR_avx512vl_ashrvv8hi_mask = 5297,
CODE_FOR_avx512vl_ashrvv16hi = 5298,
CODE_FOR_avx512vl_ashrvv16hi_mask = 5299,
CODE_FOR_avx512bw_ashrvv32hi = 5300,
CODE_FOR_avx512bw_ashrvv32hi_mask = 5301,
CODE_FOR_avx512f_ashlvv16si = 5302,
CODE_FOR_avx512f_ashlvv16si_mask = 5303,
CODE_FOR_avx512f_lshrvv16si = 5304,
CODE_FOR_avx512f_lshrvv16si_mask = 5305,
CODE_FOR_avx2_ashlvv8si = 5306,
CODE_FOR_avx2_ashlvv8si_mask = 5307,
CODE_FOR_avx2_lshrvv8si = 5308,
CODE_FOR_avx2_lshrvv8si_mask = 5309,
CODE_FOR_avx2_ashlvv4si = 5310,
CODE_FOR_avx2_ashlvv4si_mask = 5311,
CODE_FOR_avx2_lshrvv4si = 5312,
CODE_FOR_avx2_lshrvv4si_mask = 5313,
CODE_FOR_avx512f_ashlvv8di = 5314,
CODE_FOR_avx512f_ashlvv8di_mask = 5315,
CODE_FOR_avx512f_lshrvv8di = 5316,
CODE_FOR_avx512f_lshrvv8di_mask = 5317,
CODE_FOR_avx2_ashlvv4di = 5318,
CODE_FOR_avx2_ashlvv4di_mask = 5319,
CODE_FOR_avx2_lshrvv4di = 5320,
CODE_FOR_avx2_lshrvv4di_mask = 5321,
CODE_FOR_avx2_ashlvv2di = 5322,
CODE_FOR_avx2_ashlvv2di_mask = 5323,
CODE_FOR_avx2_lshrvv2di = 5324,
CODE_FOR_avx2_lshrvv2di_mask = 5325,
CODE_FOR_avx512vl_ashlvv8hi = 5326,
CODE_FOR_avx512vl_ashlvv8hi_mask = 5327,
CODE_FOR_avx512vl_lshrvv8hi = 5328,
CODE_FOR_avx512vl_lshrvv8hi_mask = 5329,
CODE_FOR_avx512vl_ashlvv16hi = 5330,
CODE_FOR_avx512vl_ashlvv16hi_mask = 5331,
CODE_FOR_avx512vl_lshrvv16hi = 5332,
CODE_FOR_avx512vl_lshrvv16hi_mask = 5333,
CODE_FOR_avx512bw_ashlvv32hi = 5334,
CODE_FOR_avx512bw_ashlvv32hi_mask = 5335,
CODE_FOR_avx512bw_lshrvv32hi = 5336,
CODE_FOR_avx512bw_lshrvv32hi_mask = 5337,
CODE_FOR_avx_vec_concatv32qi = 5338,
CODE_FOR_avx_vec_concatv16hi = 5339,
CODE_FOR_avx_vec_concatv8si = 5340,
CODE_FOR_avx_vec_concatv4di = 5341,
CODE_FOR_avx_vec_concatv8sf = 5342,
CODE_FOR_avx_vec_concatv4df = 5343,
CODE_FOR_avx_vec_concatv64qi = 5344,
CODE_FOR_avx_vec_concatv32hi = 5345,
CODE_FOR_avx_vec_concatv16si = 5346,
CODE_FOR_avx_vec_concatv8di = 5347,
CODE_FOR_avx_vec_concatv16sf = 5348,
CODE_FOR_avx_vec_concatv8df = 5349,
CODE_FOR_vcvtph2ps = 5350,
CODE_FOR_vcvtph2ps_mask = 5351,
CODE_FOR_vcvtph2ps256 = 5354,
CODE_FOR_vcvtph2ps256_mask = 5355,
CODE_FOR_avx512f_vcvtph2ps512_mask = 5358,
CODE_FOR_avx512f_vcvtph2ps512_mask_round = 5359,
CODE_FOR_vcvtps2ph256 = 5363,
CODE_FOR_vcvtps2ph256_mask = 5364,
CODE_FOR_avx512f_vcvtps2ph512_mask = 5368,
CODE_FOR_avx512f_compressv16si_mask = 5587,
CODE_FOR_avx512f_compressv16sf_mask = 5588,
CODE_FOR_avx512f_compressv8di_mask = 5589,
CODE_FOR_avx512f_compressv8df_mask = 5590,
CODE_FOR_avx512vl_compressv8si_mask = 5591,
CODE_FOR_avx512vl_compressv8sf_mask = 5592,
CODE_FOR_avx512vl_compressv4di_mask = 5593,
CODE_FOR_avx512vl_compressv4df_mask = 5594,
CODE_FOR_avx512vl_compressv4si_mask = 5595,
CODE_FOR_avx512vl_compressv4sf_mask = 5596,
CODE_FOR_avx512vl_compressv2di_mask = 5597,
CODE_FOR_avx512vl_compressv2df_mask = 5598,
CODE_FOR_compressv64qi_mask = 5599,
CODE_FOR_compressv16qi_mask = 5600,
CODE_FOR_compressv32qi_mask = 5601,
CODE_FOR_compressv32hi_mask = 5602,
CODE_FOR_compressv16hi_mask = 5603,
CODE_FOR_compressv8hi_mask = 5604,
CODE_FOR_avx512f_compressstorev16si_mask = 5605,
CODE_FOR_avx512f_compressstorev16sf_mask = 5606,
CODE_FOR_avx512f_compressstorev8di_mask = 5607,
CODE_FOR_avx512f_compressstorev8df_mask = 5608,
CODE_FOR_avx512vl_compressstorev8si_mask = 5609,
CODE_FOR_avx512vl_compressstorev8sf_mask = 5610,
CODE_FOR_avx512vl_compressstorev4di_mask = 5611,
CODE_FOR_avx512vl_compressstorev4df_mask = 5612,
CODE_FOR_avx512vl_compressstorev4si_mask = 5613,
CODE_FOR_avx512vl_compressstorev4sf_mask = 5614,
CODE_FOR_avx512vl_compressstorev2di_mask = 5615,
CODE_FOR_avx512vl_compressstorev2df_mask = 5616,
CODE_FOR_compressstorev64qi_mask = 5617,
CODE_FOR_compressstorev16qi_mask = 5618,
CODE_FOR_compressstorev32qi_mask = 5619,
CODE_FOR_compressstorev32hi_mask = 5620,
CODE_FOR_compressstorev16hi_mask = 5621,
CODE_FOR_compressstorev8hi_mask = 5622,
CODE_FOR_avx512f_expandv16si_mask = 5623,
CODE_FOR_avx512f_expandv16sf_mask = 5624,
CODE_FOR_avx512f_expandv8di_mask = 5625,
CODE_FOR_avx512f_expandv8df_mask = 5626,
CODE_FOR_avx512vl_expandv8si_mask = 5627,
CODE_FOR_avx512vl_expandv8sf_mask = 5628,
CODE_FOR_avx512vl_expandv4di_mask = 5629,
CODE_FOR_avx512vl_expandv4df_mask = 5630,
CODE_FOR_avx512vl_expandv4si_mask = 5631,
CODE_FOR_avx512vl_expandv4sf_mask = 5632,
CODE_FOR_avx512vl_expandv2di_mask = 5633,
CODE_FOR_avx512vl_expandv2df_mask = 5634,
CODE_FOR_expandv64qi_mask = 5635,
CODE_FOR_expandv16qi_mask = 5636,
CODE_FOR_expandv32qi_mask = 5637,
CODE_FOR_expandv32hi_mask = 5638,
CODE_FOR_expandv16hi_mask = 5639,
CODE_FOR_expandv8hi_mask = 5640,
CODE_FOR_avx512dq_rangepv16sf = 5641,
CODE_FOR_avx512dq_rangepv16sf_round = 5642,
CODE_FOR_avx512dq_rangepv16sf_mask = 5643,
CODE_FOR_avx512dq_rangepv16sf_mask_round = 5644,
CODE_FOR_avx512dq_rangepv8sf = 5645,
CODE_FOR_avx512dq_rangepv8sf_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv8sf_mask = 5646,
CODE_FOR_avx512dq_rangepv8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv4sf = 5647,
CODE_FOR_avx512dq_rangepv4sf_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv4sf_mask = 5648,
CODE_FOR_avx512dq_rangepv4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv8df = 5649,
CODE_FOR_avx512dq_rangepv8df_round = 5650,
CODE_FOR_avx512dq_rangepv8df_mask = 5651,
CODE_FOR_avx512dq_rangepv8df_mask_round = 5652,
CODE_FOR_avx512dq_rangepv4df = 5653,
CODE_FOR_avx512dq_rangepv4df_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv4df_mask = 5654,
CODE_FOR_avx512dq_rangepv4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv2df = 5655,
CODE_FOR_avx512dq_rangepv2df_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv2df_mask = 5656,
CODE_FOR_avx512dq_rangepv2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangesv4sf = 5657,
CODE_FOR_avx512dq_rangesv4sf_mask = 5658,
CODE_FOR_avx512dq_rangesv4sf_round = 5659,
CODE_FOR_avx512dq_rangesv4sf_mask_round = 5660,
CODE_FOR_avx512dq_rangesv2df = 5661,
CODE_FOR_avx512dq_rangesv2df_mask = 5662,
CODE_FOR_avx512dq_rangesv2df_round = 5663,
CODE_FOR_avx512dq_rangesv2df_mask_round = 5664,
CODE_FOR_avx512dq_fpclassv16sf = 5665,
CODE_FOR_avx512dq_fpclassv16sf_mask = 5666,
CODE_FOR_avx512dq_fpclassv8sf = 5667,
CODE_FOR_avx512dq_fpclassv8sf_mask = 5668,
CODE_FOR_avx512dq_fpclassv4sf = 5669,
CODE_FOR_avx512dq_fpclassv4sf_mask = 5670,
CODE_FOR_avx512dq_fpclassv8df = 5671,
CODE_FOR_avx512dq_fpclassv8df_mask = 5672,
CODE_FOR_avx512dq_fpclassv4df = 5673,
CODE_FOR_avx512dq_fpclassv4df_mask = 5674,
CODE_FOR_avx512dq_fpclassv2df = 5675,
CODE_FOR_avx512dq_fpclassv2df_mask = 5676,
CODE_FOR_avx512dq_vmfpclassv4sf = 5677,
CODE_FOR_avx512dq_vmfpclassv4sf_mask = 5678,
CODE_FOR_avx512dq_vmfpclassv2df = 5679,
CODE_FOR_avx512dq_vmfpclassv2df_mask = 5680,
CODE_FOR_avx512f_getmantv16sf = 5681,
CODE_FOR_avx512f_getmantv16sf_round = 5682,
CODE_FOR_avx512f_getmantv16sf_mask = 5683,
CODE_FOR_avx512f_getmantv16sf_mask_round = 5684,
CODE_FOR_avx512vl_getmantv8sf = 5685,
CODE_FOR_avx512vl_getmantv8sf_round = 5686,
CODE_FOR_avx512vl_getmantv8sf_mask = 5687,
CODE_FOR_avx512vl_getmantv8sf_mask_round = 5688,
CODE_FOR_avx512vl_getmantv4sf = 5689,
CODE_FOR_avx512vl_getmantv4sf_round = 5690,
CODE_FOR_avx512vl_getmantv4sf_mask = 5691,
CODE_FOR_avx512vl_getmantv4sf_mask_round = 5692,
CODE_FOR_avx512f_getmantv8df = 5693,
CODE_FOR_avx512f_getmantv8df_round = 5694,
CODE_FOR_avx512f_getmantv8df_mask = 5695,
CODE_FOR_avx512f_getmantv8df_mask_round = 5696,
CODE_FOR_avx512vl_getmantv4df = 5697,
CODE_FOR_avx512vl_getmantv4df_round = 5698,
CODE_FOR_avx512vl_getmantv4df_mask = 5699,
CODE_FOR_avx512vl_getmantv4df_mask_round = 5700,
CODE_FOR_avx512vl_getmantv2df = 5701,
CODE_FOR_avx512vl_getmantv2df_round = 5702,
CODE_FOR_avx512vl_getmantv2df_mask = 5703,
CODE_FOR_avx512vl_getmantv2df_mask_round = 5704,
CODE_FOR_avx512f_vgetmantv4sf = 5705,
CODE_FOR_avx512f_vgetmantv4sf_mask = 5706,
CODE_FOR_avx512f_vgetmantv4sf_round = 5707,
CODE_FOR_avx512f_vgetmantv4sf_mask_round = 5708,
CODE_FOR_avx512f_vgetmantv2df = 5709,
CODE_FOR_avx512f_vgetmantv2df_mask = 5710,
CODE_FOR_avx512f_vgetmantv2df_round = 5711,
CODE_FOR_avx512f_vgetmantv2df_mask_round = 5712,
CODE_FOR_avx512bw_dbpsadbwv8hi_mask = 5714,
CODE_FOR_avx512bw_dbpsadbwv16hi_mask = 5716,
CODE_FOR_avx512bw_dbpsadbwv32hi_mask = 5718,
CODE_FOR_clzv16si2 = 5719,
CODE_FOR_clzv16si2_mask = 5720,
CODE_FOR_clzv8si2 = 5721,
CODE_FOR_clzv8si2_mask = 5722,
CODE_FOR_clzv4si2 = 5723,
CODE_FOR_clzv4si2_mask = 5724,
CODE_FOR_clzv8di2 = 5725,
CODE_FOR_clzv8di2_mask = 5726,
CODE_FOR_clzv4di2 = 5727,
CODE_FOR_clzv4di2_mask = 5728,
CODE_FOR_clzv2di2 = 5729,
CODE_FOR_clzv2di2_mask = 5730,
CODE_FOR_conflictv16si_mask = 5732,
CODE_FOR_conflictv8si_mask = 5734,
CODE_FOR_conflictv4si_mask = 5736,
CODE_FOR_conflictv8di_mask = 5738,
CODE_FOR_conflictv4di_mask = 5740,
CODE_FOR_conflictv2di_mask = 5742,
CODE_FOR_sha1msg1 = 5743,
CODE_FOR_sha1msg2 = 5744,
CODE_FOR_sha1nexte = 5745,
CODE_FOR_sha1rnds4 = 5746,
CODE_FOR_sha256msg1 = 5747,
CODE_FOR_sha256msg2 = 5748,
CODE_FOR_sha256rnds2 = 5749,
CODE_FOR_avx512f_si512_si = 5750,
CODE_FOR_avx512f_ps512_ps = 5751,
CODE_FOR_avx512f_pd512_pd = 5752,
CODE_FOR_avx512f_si512_256si = 5753,
CODE_FOR_avx512f_ps512_256ps = 5754,
CODE_FOR_avx512f_pd512_256pd = 5755,
CODE_FOR_vpamdd52luqv8di = 5756,
CODE_FOR_vpamdd52luqv8di_maskz_1 = 5757,
CODE_FOR_vpamdd52huqv8di = 5758,
CODE_FOR_vpamdd52huqv8di_maskz_1 = 5759,
CODE_FOR_vpamdd52luqv4di = 5760,
CODE_FOR_vpamdd52luqv4di_maskz_1 = 5761,
CODE_FOR_vpamdd52huqv4di = 5762,
CODE_FOR_vpamdd52huqv4di_maskz_1 = 5763,
CODE_FOR_vpamdd52luqv2di = 5764,
CODE_FOR_vpamdd52luqv2di_maskz_1 = 5765,
CODE_FOR_vpamdd52huqv2di = 5766,
CODE_FOR_vpamdd52huqv2di_maskz_1 = 5767,
CODE_FOR_vpamdd52luqv8di_mask = 5768,
CODE_FOR_vpamdd52huqv8di_mask = 5769,
CODE_FOR_vpamdd52luqv4di_mask = 5770,
CODE_FOR_vpamdd52huqv4di_mask = 5771,
CODE_FOR_vpamdd52luqv2di_mask = 5772,
CODE_FOR_vpamdd52huqv2di_mask = 5773,
CODE_FOR_vpmultishiftqbv64qi = 5774,
CODE_FOR_vpmultishiftqbv64qi_mask = 5775,
CODE_FOR_vpmultishiftqbv16qi = 5776,
CODE_FOR_vpmultishiftqbv16qi_mask = 5777,
CODE_FOR_vpmultishiftqbv32qi = 5778,
CODE_FOR_vpmultishiftqbv32qi_mask = 5779,
CODE_FOR_avx5124fmaddps_4fmaddps = 5782,
CODE_FOR_avx5124fmaddps_4fmaddps_mask = 5783,
CODE_FOR_avx5124fmaddps_4fmaddps_maskz = 5784,
CODE_FOR_avx5124fmaddps_4fmaddss = 5785,
CODE_FOR_avx5124fmaddps_4fmaddss_mask = 5786,
CODE_FOR_avx5124fmaddps_4fmaddss_maskz = 5787,
CODE_FOR_avx5124fmaddps_4fnmaddps = 5788,
CODE_FOR_avx5124fmaddps_4fnmaddps_mask = 5789,
CODE_FOR_avx5124fmaddps_4fnmaddps_maskz = 5790,
CODE_FOR_avx5124fmaddps_4fnmaddss = 5791,
CODE_FOR_avx5124fmaddps_4fnmaddss_mask = 5792,
CODE_FOR_avx5124fmaddps_4fnmaddss_maskz = 5793,
CODE_FOR_avx5124vnniw_vp4dpwssd = 5794,
CODE_FOR_avx5124vnniw_vp4dpwssd_mask = 5795,
CODE_FOR_avx5124vnniw_vp4dpwssd_maskz = 5796,
CODE_FOR_avx5124vnniw_vp4dpwssds = 5797,
CODE_FOR_avx5124vnniw_vp4dpwssds_mask = 5798,
CODE_FOR_avx5124vnniw_vp4dpwssds_maskz = 5799,
CODE_FOR_vpopcountv16si = 5800,
CODE_FOR_vpopcountv16si_mask = 5801,
CODE_FOR_vpopcountv8si = 5802,
CODE_FOR_vpopcountv8si_mask = 5803,
CODE_FOR_vpopcountv4si = 5804,
CODE_FOR_vpopcountv4si_mask = 5805,
CODE_FOR_vpopcountv8di = 5806,
CODE_FOR_vpopcountv8di_mask = 5807,
CODE_FOR_vpopcountv4di = 5808,
CODE_FOR_vpopcountv4di_mask = 5809,
CODE_FOR_vpopcountv2di = 5810,
CODE_FOR_vpopcountv2di_mask = 5811,
CODE_FOR_vpopcountv64qi = 5820,
CODE_FOR_vpopcountv64qi_mask = 5821,
CODE_FOR_vpopcountv16qi = 5822,
CODE_FOR_vpopcountv16qi_mask = 5823,
CODE_FOR_vpopcountv32qi = 5824,
CODE_FOR_vpopcountv32qi_mask = 5825,
CODE_FOR_vpopcountv32hi = 5826,
CODE_FOR_vpopcountv32hi_mask = 5827,
CODE_FOR_vpopcountv16hi = 5828,
CODE_FOR_vpopcountv16hi_mask = 5829,
CODE_FOR_vpopcountv8hi = 5830,
CODE_FOR_vpopcountv8hi_mask = 5831,
CODE_FOR_vgf2p8affineinvqb_v64qi = 5832,
CODE_FOR_vgf2p8affineinvqb_v64qi_mask = 5833,
CODE_FOR_vgf2p8affineinvqb_v32qi = 5834,
CODE_FOR_vgf2p8affineinvqb_v32qi_mask = 5835,
CODE_FOR_vgf2p8affineinvqb_v16qi = 5836,
CODE_FOR_vgf2p8affineinvqb_v16qi_mask = 5837,
CODE_FOR_vgf2p8affineqb_v64qi = 5838,
CODE_FOR_vgf2p8affineqb_v64qi_mask = 5839,
CODE_FOR_vgf2p8affineqb_v32qi = 5840,
CODE_FOR_vgf2p8affineqb_v32qi_mask = 5841,
CODE_FOR_vgf2p8affineqb_v16qi = 5842,
CODE_FOR_vgf2p8affineqb_v16qi_mask = 5843,
CODE_FOR_vgf2p8mulb_v64qi = 5844,
CODE_FOR_vgf2p8mulb_v64qi_mask = 5845,
CODE_FOR_vgf2p8mulb_v32qi = 5846,
CODE_FOR_vgf2p8mulb_v32qi_mask = 5847,
CODE_FOR_vgf2p8mulb_v16qi = 5848,
CODE_FOR_vgf2p8mulb_v16qi_mask = 5849,
CODE_FOR_vpshrd_v32hi = 5850,
CODE_FOR_vpshrd_v32hi_mask = 5851,
CODE_FOR_vpshrd_v16si = 5852,
CODE_FOR_vpshrd_v16si_mask = 5853,
CODE_FOR_vpshrd_v8di = 5854,
CODE_FOR_vpshrd_v8di_mask = 5855,
CODE_FOR_vpshrd_v16hi = 5856,
CODE_FOR_vpshrd_v16hi_mask = 5857,
CODE_FOR_vpshrd_v8si = 5858,
CODE_FOR_vpshrd_v8si_mask = 5859,
CODE_FOR_vpshrd_v4di = 5860,
CODE_FOR_vpshrd_v4di_mask = 5861,
CODE_FOR_vpshrd_v8hi = 5862,
CODE_FOR_vpshrd_v8hi_mask = 5863,
CODE_FOR_vpshrd_v4si = 5864,
CODE_FOR_vpshrd_v4si_mask = 5865,
CODE_FOR_vpshrd_v2di = 5866,
CODE_FOR_vpshrd_v2di_mask = 5867,
CODE_FOR_vpshld_v32hi = 5868,
CODE_FOR_vpshld_v32hi_mask = 5869,
CODE_FOR_vpshld_v16si = 5870,
CODE_FOR_vpshld_v16si_mask = 5871,
CODE_FOR_vpshld_v8di = 5872,
CODE_FOR_vpshld_v8di_mask = 5873,
CODE_FOR_vpshld_v16hi = 5874,
CODE_FOR_vpshld_v16hi_mask = 5875,
CODE_FOR_vpshld_v8si = 5876,
CODE_FOR_vpshld_v8si_mask = 5877,
CODE_FOR_vpshld_v4di = 5878,
CODE_FOR_vpshld_v4di_mask = 5879,
CODE_FOR_vpshld_v8hi = 5880,
CODE_FOR_vpshld_v8hi_mask = 5881,
CODE_FOR_vpshld_v4si = 5882,
CODE_FOR_vpshld_v4si_mask = 5883,
CODE_FOR_vpshld_v2di = 5884,
CODE_FOR_vpshld_v2di_mask = 5885,
CODE_FOR_vpshrdv_v32hi = 5886,
CODE_FOR_vpshrdv_v16si = 5887,
CODE_FOR_vpshrdv_v8di = 5888,
CODE_FOR_vpshrdv_v16hi = 5889,
CODE_FOR_vpshrdv_v8si = 5890,
CODE_FOR_vpshrdv_v4di = 5891,
CODE_FOR_vpshrdv_v8hi = 5892,
CODE_FOR_vpshrdv_v4si = 5893,
CODE_FOR_vpshrdv_v2di = 5894,
CODE_FOR_vpshrdv_v32hi_mask = 5895,
CODE_FOR_vpshrdv_v16si_mask = 5896,
CODE_FOR_vpshrdv_v8di_mask = 5897,
CODE_FOR_vpshrdv_v16hi_mask = 5898,
CODE_FOR_vpshrdv_v8si_mask = 5899,
CODE_FOR_vpshrdv_v4di_mask = 5900,
CODE_FOR_vpshrdv_v8hi_mask = 5901,
CODE_FOR_vpshrdv_v4si_mask = 5902,
CODE_FOR_vpshrdv_v2di_mask = 5903,
CODE_FOR_vpshrdv_v32hi_maskz_1 = 5904,
CODE_FOR_vpshrdv_v16si_maskz_1 = 5905,
CODE_FOR_vpshrdv_v8di_maskz_1 = 5906,
CODE_FOR_vpshrdv_v16hi_maskz_1 = 5907,
CODE_FOR_vpshrdv_v8si_maskz_1 = 5908,
CODE_FOR_vpshrdv_v4di_maskz_1 = 5909,
CODE_FOR_vpshrdv_v8hi_maskz_1 = 5910,
CODE_FOR_vpshrdv_v4si_maskz_1 = 5911,
CODE_FOR_vpshrdv_v2di_maskz_1 = 5912,
CODE_FOR_vpshldv_v32hi = 5913,
CODE_FOR_vpshldv_v16si = 5914,
CODE_FOR_vpshldv_v8di = 5915,
CODE_FOR_vpshldv_v16hi = 5916,
CODE_FOR_vpshldv_v8si = 5917,
CODE_FOR_vpshldv_v4di = 5918,
CODE_FOR_vpshldv_v8hi = 5919,
CODE_FOR_vpshldv_v4si = 5920,
CODE_FOR_vpshldv_v2di = 5921,
CODE_FOR_vpshldv_v32hi_mask = 5922,
CODE_FOR_vpshldv_v16si_mask = 5923,
CODE_FOR_vpshldv_v8di_mask = 5924,
CODE_FOR_vpshldv_v16hi_mask = 5925,
CODE_FOR_vpshldv_v8si_mask = 5926,
CODE_FOR_vpshldv_v4di_mask = 5927,
CODE_FOR_vpshldv_v8hi_mask = 5928,
CODE_FOR_vpshldv_v4si_mask = 5929,
CODE_FOR_vpshldv_v2di_mask = 5930,
CODE_FOR_vpshldv_v32hi_maskz_1 = 5931,
CODE_FOR_vpshldv_v16si_maskz_1 = 5932,
CODE_FOR_vpshldv_v8di_maskz_1 = 5933,
CODE_FOR_vpshldv_v16hi_maskz_1 = 5934,
CODE_FOR_vpshldv_v8si_maskz_1 = 5935,
CODE_FOR_vpshldv_v4di_maskz_1 = 5936,
CODE_FOR_vpshldv_v8hi_maskz_1 = 5937,
CODE_FOR_vpshldv_v4si_maskz_1 = 5938,
CODE_FOR_vpshldv_v2di_maskz_1 = 5939,
CODE_FOR_vpdpbusd_v16si = 5940,
CODE_FOR_vpdpbusd_v8si = 5941,
CODE_FOR_vpdpbusd_v4si = 5942,
CODE_FOR_vpdpbusd_v16si_mask = 5943,
CODE_FOR_vpdpbusd_v8si_mask = 5944,
CODE_FOR_vpdpbusd_v4si_mask = 5945,
CODE_FOR_vpdpbusd_v16si_maskz_1 = 5946,
CODE_FOR_vpdpbusd_v8si_maskz_1 = 5947,
CODE_FOR_vpdpbusd_v4si_maskz_1 = 5948,
CODE_FOR_vpdpbusds_v16si = 5949,
CODE_FOR_vpdpbusds_v8si = 5950,
CODE_FOR_vpdpbusds_v4si = 5951,
CODE_FOR_vpdpbusds_v16si_mask = 5952,
CODE_FOR_vpdpbusds_v8si_mask = 5953,
CODE_FOR_vpdpbusds_v4si_mask = 5954,
CODE_FOR_vpdpbusds_v16si_maskz_1 = 5955,
CODE_FOR_vpdpbusds_v8si_maskz_1 = 5956,
CODE_FOR_vpdpbusds_v4si_maskz_1 = 5957,
CODE_FOR_vpdpwssd_v16si = 5958,
CODE_FOR_vpdpwssd_v8si = 5959,
CODE_FOR_vpdpwssd_v4si = 5960,
CODE_FOR_vpdpwssd_v16si_mask = 5961,
CODE_FOR_vpdpwssd_v8si_mask = 5962,
CODE_FOR_vpdpwssd_v4si_mask = 5963,
CODE_FOR_vpdpwssd_v16si_maskz_1 = 5964,
CODE_FOR_vpdpwssd_v8si_maskz_1 = 5965,
CODE_FOR_vpdpwssd_v4si_maskz_1 = 5966,
CODE_FOR_vpdpwssds_v16si = 5967,
CODE_FOR_vpdpwssds_v8si = 5968,
CODE_FOR_vpdpwssds_v4si = 5969,
CODE_FOR_vpdpwssds_v16si_mask = 5970,
CODE_FOR_vpdpwssds_v8si_mask = 5971,
CODE_FOR_vpdpwssds_v4si_mask = 5972,
CODE_FOR_vpdpwssds_v16si_maskz_1 = 5973,
CODE_FOR_vpdpwssds_v8si_maskz_1 = 5974,
CODE_FOR_vpdpwssds_v4si_maskz_1 = 5975,
CODE_FOR_vaesdec_v32qi = 5976,
CODE_FOR_vaesdec_v16qi = 5977,
CODE_FOR_vaesdec_v64qi = 5978,
CODE_FOR_vaesdeclast_v32qi = 5979,
CODE_FOR_vaesdeclast_v16qi = 5980,
CODE_FOR_vaesdeclast_v64qi = 5981,
CODE_FOR_vaesenc_v32qi = 5982,
CODE_FOR_vaesenc_v16qi = 5983,
CODE_FOR_vaesenc_v64qi = 5984,
CODE_FOR_vaesenclast_v32qi = 5985,
CODE_FOR_vaesenclast_v16qi = 5986,
CODE_FOR_vaesenclast_v64qi = 5987,
CODE_FOR_vpclmulqdq_v8di = 5988,
CODE_FOR_vpclmulqdq_v4di = 5989,
CODE_FOR_vpclmulqdq_v2di = 5990,
CODE_FOR_avx512vl_vpshufbitqmbv64qi = 5991,
CODE_FOR_avx512vl_vpshufbitqmbv64qi_mask = 5992,
CODE_FOR_avx512vl_vpshufbitqmbv32qi = 5993,
CODE_FOR_avx512vl_vpshufbitqmbv32qi_mask = 5994,
CODE_FOR_avx512vl_vpshufbitqmbv16qi = 5995,
CODE_FOR_avx512vl_vpshufbitqmbv16qi_mask = 5996,
CODE_FOR_avx512vp2intersect_2intersectv8di = 5997,
CODE_FOR_avx512vp2intersect_2intersectv4di = 5998,
CODE_FOR_avx512vp2intersect_2intersectv2di = 5999,
CODE_FOR_avx512vp2intersect_2intersectv8si = 6000,
CODE_FOR_avx512vp2intersect_2intersectv4si = 6001,
CODE_FOR_avx512vp2intersect_2intersectv16si = 6002,
CODE_FOR_avx512f_cvtne2ps2bf16_v32hi = 6003,
CODE_FOR_avx512f_cvtne2ps2bf16_v32hi_mask = 6004,
CODE_FOR_avx512f_cvtne2ps2bf16_v16hi = 6005,
CODE_FOR_avx512f_cvtne2ps2bf16_v16hi_mask = 6006,
CODE_FOR_avx512f_cvtne2ps2bf16_v8hi = 6007,
CODE_FOR_avx512f_cvtne2ps2bf16_v8hi_mask = 6008,
CODE_FOR_avx512f_cvtneps2bf16_v16sf = 6009,
CODE_FOR_avx512f_cvtneps2bf16_v16sf_mask = 6010,
CODE_FOR_avx512f_cvtneps2bf16_v8sf = 6011,
CODE_FOR_avx512f_cvtneps2bf16_v8sf_mask = 6012,
CODE_FOR_avx512f_cvtneps2bf16_v4sf = 6013,
CODE_FOR_avx512f_cvtneps2bf16_v4sf_mask = 6014,
CODE_FOR_avx512f_dpbf16ps_v16sf = 6015,
CODE_FOR_avx512f_dpbf16ps_v16sf_maskz_1 = 6016,
CODE_FOR_avx512f_dpbf16ps_v8sf = 6017,
CODE_FOR_avx512f_dpbf16ps_v8sf_maskz_1 = 6018,
CODE_FOR_avx512f_dpbf16ps_v4sf = 6019,
CODE_FOR_avx512f_dpbf16ps_v4sf_maskz_1 = 6020,
CODE_FOR_avx512f_dpbf16ps_v16sf_mask = 6021,
CODE_FOR_avx512f_dpbf16ps_v8sf_mask = 6022,
CODE_FOR_avx512f_dpbf16ps_v4sf_mask = 6023,
CODE_FOR_mfence_sse2 = 6026,
CODE_FOR_mfence_nosse = 6027,
CODE_FOR_atomic_loaddi_fpu = 6028,
CODE_FOR_atomic_storeqi_1 = 6029,
CODE_FOR_atomic_storehi_1 = 6030,
CODE_FOR_atomic_storesi_1 = 6031,
CODE_FOR_atomic_storedi_1 = 6032,
CODE_FOR_atomic_storedi_fpu = 6033,
CODE_FOR_loaddi_via_fpu = 6034,
CODE_FOR_storedi_via_fpu = 6035,
CODE_FOR_loaddi_via_sse = 6036,
CODE_FOR_storedi_via_sse = 6037,
CODE_FOR_atomic_compare_and_swapdi_doubleword = 6038,
CODE_FOR_atomic_compare_and_swapti_doubleword = 6039,
CODE_FOR_atomic_compare_and_swapqi_1 = 6040,
CODE_FOR_atomic_compare_and_swaphi_1 = 6041,
CODE_FOR_atomic_compare_and_swapsi_1 = 6042,
CODE_FOR_atomic_compare_and_swapdi_1 = 6043,
CODE_FOR_atomic_fetch_addqi = 6044,
CODE_FOR_atomic_fetch_addhi = 6045,
CODE_FOR_atomic_fetch_addsi = 6046,
CODE_FOR_atomic_fetch_adddi = 6047,
CODE_FOR_atomic_exchangeqi = 6052,
CODE_FOR_atomic_exchangehi = 6053,
CODE_FOR_atomic_exchangesi = 6054,
CODE_FOR_atomic_exchangedi = 6055,
CODE_FOR_atomic_addqi = 6056,
CODE_FOR_atomic_addhi = 6057,
CODE_FOR_atomic_addsi = 6058,
CODE_FOR_atomic_adddi = 6059,
CODE_FOR_atomic_subqi = 6060,
CODE_FOR_atomic_subhi = 6061,
CODE_FOR_atomic_subsi = 6062,
CODE_FOR_atomic_subdi = 6063,
CODE_FOR_atomic_andqi = 6064,
CODE_FOR_atomic_orqi = 6065,
CODE_FOR_atomic_xorqi = 6066,
CODE_FOR_atomic_andhi = 6067,
CODE_FOR_atomic_orhi = 6068,
CODE_FOR_atomic_xorhi = 6069,
CODE_FOR_atomic_andsi = 6070,
CODE_FOR_atomic_orsi = 6071,
CODE_FOR_atomic_xorsi = 6072,
CODE_FOR_atomic_anddi = 6073,
CODE_FOR_atomic_ordi = 6074,
CODE_FOR_atomic_xordi = 6075,
CODE_FOR_atomic_bit_test_and_sethi_1 = 6076,
CODE_FOR_atomic_bit_test_and_setsi_1 = 6077,
CODE_FOR_atomic_bit_test_and_setdi_1 = 6078,
CODE_FOR_atomic_bit_test_and_complementhi_1 = 6079,
CODE_FOR_atomic_bit_test_and_complementsi_1 = 6080,
CODE_FOR_atomic_bit_test_and_complementdi_1 = 6081,
CODE_FOR_atomic_bit_test_and_resethi_1 = 6082,
CODE_FOR_atomic_bit_test_and_resetsi_1 = 6083,
CODE_FOR_atomic_bit_test_and_resetdi_1 = 6084,
CODE_FOR_cbranchqi4 = 6085,
CODE_FOR_cbranchhi4 = 6086,
CODE_FOR_cbranchsi4 = 6087,
CODE_FOR_cbranchdi4 = 6088,
CODE_FOR_cbranchti4 = 6089,
CODE_FOR_cstoreqi4 = 6090,
CODE_FOR_cstorehi4 = 6091,
CODE_FOR_cstoresi4 = 6092,
CODE_FOR_cstoredi4 = 6093,
CODE_FOR_cmpsi_1 = 6094,
CODE_FOR_cmpdi_1 = 6095,
CODE_FOR_cmpqi_ext_3 = 6096,
CODE_FOR_cbranchxf4 = 6097,
CODE_FOR_cstorexf4 = 6098,
CODE_FOR_cbranchsf4 = 6099,
CODE_FOR_cbranchdf4 = 6100,
CODE_FOR_cstoresf4 = 6101,
CODE_FOR_cstoredf4 = 6102,
CODE_FOR_cbranchcc4 = 6103,
CODE_FOR_cstorecc4 = 6104,
CODE_FOR_reload_noff_store = 6105,
CODE_FOR_reload_noff_load = 6106,
CODE_FOR_movxi = 6107,
CODE_FOR_movoi = 6108,
CODE_FOR_movti = 6109,
CODE_FOR_movcdi = 6110,
CODE_FOR_movqi = 6111,
CODE_FOR_movhi = 6112,
CODE_FOR_movsi = 6113,
CODE_FOR_movdi = 6114,
CODE_FOR_movstrictqi = 6115,
CODE_FOR_movstricthi = 6116,
CODE_FOR_extvhi = 6117,
CODE_FOR_extvsi = 6118,
CODE_FOR_extzvhi = 6119,
CODE_FOR_extzvsi = 6120,
CODE_FOR_extzvdi = 6121,
CODE_FOR_insvhi = 6122,
CODE_FOR_insvsi = 6123,
CODE_FOR_insvdi = 6124,
CODE_FOR_movtf = 6125,
CODE_FOR_movsf = 6126,
CODE_FOR_movdf = 6127,
CODE_FOR_movxf = 6128,
CODE_FOR_zero_extendsidi2 = 6129,
CODE_FOR_zero_extendqisi2 = 6130,
CODE_FOR_zero_extendhisi2 = 6131,
CODE_FOR_zero_extendqihi2 = 6132,
CODE_FOR_extendsidi2 = 6133,
CODE_FOR_extendsfdf2 = 6134,
CODE_FOR_extendsfxf2 = 6135,
CODE_FOR_extenddfxf2 = 6136,
CODE_FOR_fix_truncxfdi2 = 6137,
CODE_FOR_fix_truncsfdi2 = 6138,
CODE_FOR_fix_truncdfdi2 = 6139,
CODE_FOR_fix_truncxfsi2 = 6140,
CODE_FOR_fix_truncsfsi2 = 6141,
CODE_FOR_fix_truncdfsi2 = 6142,
CODE_FOR_fix_truncsfhi2 = 6143,
CODE_FOR_fix_truncdfhi2 = 6144,
CODE_FOR_fix_truncxfhi2 = 6145,
CODE_FOR_fixuns_truncsfsi2 = 6146,
CODE_FOR_fixuns_truncdfsi2 = 6147,
CODE_FOR_fixuns_truncsfhi2 = 6148,
CODE_FOR_fixuns_truncdfhi2 = 6149,
CODE_FOR_floatsisf2 = 6150,
CODE_FOR_floatdisf2 = 6151,
CODE_FOR_floatsidf2 = 6152,
CODE_FOR_floatdidf2 = 6153,
CODE_FOR_floatunsqisf2 = 6154,
CODE_FOR_floatunshisf2 = 6155,
CODE_FOR_floatunsqidf2 = 6156,
CODE_FOR_floatunshidf2 = 6157,
CODE_FOR_floatunssisf2 = 6158,
CODE_FOR_floatunssidf2 = 6159,
CODE_FOR_floatunssixf2 = 6160,
CODE_FOR_floatunsdisf2 = 6161,
CODE_FOR_floatunsdidf2 = 6162,
CODE_FOR_addqi3 = 6163,
CODE_FOR_addhi3 = 6164,
CODE_FOR_addsi3 = 6165,
CODE_FOR_adddi3 = 6166,
CODE_FOR_addti3 = 6167,
CODE_FOR_addqi_ext_1 = 6168,
CODE_FOR_addvqi4 = 6169,
CODE_FOR_addvhi4 = 6170,
CODE_FOR_addvsi4 = 6171,
CODE_FOR_addvdi4 = 6172,
CODE_FOR_addvti4 = 6173,
CODE_FOR_uaddvqi4 = 6174,
CODE_FOR_uaddvhi4 = 6175,
CODE_FOR_uaddvsi4 = 6176,
CODE_FOR_uaddvdi4 = 6177,
CODE_FOR_uaddvti4 = 6178,
CODE_FOR_subqi3 = 6179,
CODE_FOR_subhi3 = 6180,
CODE_FOR_subsi3 = 6181,
CODE_FOR_subdi3 = 6182,
CODE_FOR_subti3 = 6183,
CODE_FOR_subvqi4 = 6184,
CODE_FOR_subvhi4 = 6185,
CODE_FOR_subvsi4 = 6186,
CODE_FOR_subvdi4 = 6187,
CODE_FOR_subvti4 = 6188,
CODE_FOR_usubvqi4 = 6189,
CODE_FOR_usubvhi4 = 6190,
CODE_FOR_usubvsi4 = 6191,
CODE_FOR_usubvdi4 = 6192,
CODE_FOR_addcarrysi_0 = 6193,
CODE_FOR_addcarrydi_0 = 6194,
CODE_FOR_subborrowsi_0 = 6195,
CODE_FOR_subborrowdi_0 = 6196,
CODE_FOR_addqi3_cconly_overflow = 6197,
CODE_FOR_addxf3 = 6198,
CODE_FOR_subxf3 = 6199,
CODE_FOR_addsf3 = 6200,
CODE_FOR_subsf3 = 6201,
CODE_FOR_adddf3 = 6202,
CODE_FOR_subdf3 = 6203,
CODE_FOR_mulhi3 = 6204,
CODE_FOR_mulsi3 = 6205,
CODE_FOR_muldi3 = 6206,
CODE_FOR_mulqi3 = 6207,
CODE_FOR_mulvhi4 = 6208,
CODE_FOR_mulvsi4 = 6209,
CODE_FOR_mulvdi4 = 6210,
CODE_FOR_umulvhi4 = 6211,
CODE_FOR_umulvsi4 = 6212,
CODE_FOR_umulvdi4 = 6213,
CODE_FOR_mulvqi4 = 6214,
CODE_FOR_umulvqi4 = 6215,
CODE_FOR_mulsidi3 = 6216,
CODE_FOR_umulsidi3 = 6217,
CODE_FOR_mulditi3 = 6218,
CODE_FOR_umulditi3 = 6219,
CODE_FOR_mulqihi3 = 6220,
CODE_FOR_umulqihi3 = 6221,
CODE_FOR_smulsi3_highpart = 6222,
CODE_FOR_umulsi3_highpart = 6223,
CODE_FOR_smuldi3_highpart = 6224,
CODE_FOR_umuldi3_highpart = 6225,
CODE_FOR_mulxf3 = 6226,
CODE_FOR_mulsf3 = 6227,
CODE_FOR_muldf3 = 6228,
CODE_FOR_divxf3 = 6229,
CODE_FOR_divsf3 = 6230,
CODE_FOR_divdf3 = 6231,
CODE_FOR_divmodhi4 = 6232,
CODE_FOR_udivmodhi4 = 6233,
CODE_FOR_divmodsi4 = 6234,
CODE_FOR_udivmodsi4 = 6235,
CODE_FOR_divmoddi4 = 6236,
CODE_FOR_udivmoddi4 = 6237,
CODE_FOR_divmodqi4 = 6238,
CODE_FOR_udivmodqi4 = 6239,
CODE_FOR_testsi_ccno_1 = 6240,
CODE_FOR_testdi_ccno_1 = 6241,
CODE_FOR_testqi_ccz_1 = 6242,
CODE_FOR_testqi_ext_1_ccno = 6243,
CODE_FOR_andqi3 = 6244,
CODE_FOR_andhi3 = 6245,
CODE_FOR_andsi3 = 6246,
CODE_FOR_anddi3 = 6247,
CODE_FOR_andqi_ext_1 = 6248,
CODE_FOR_iorqi3 = 6249,
CODE_FOR_xorqi3 = 6250,
CODE_FOR_iorhi3 = 6251,
CODE_FOR_xorhi3 = 6252,
CODE_FOR_iorsi3 = 6253,
CODE_FOR_xorsi3 = 6254,
CODE_FOR_iordi3 = 6255,
CODE_FOR_xordi3 = 6256,
CODE_FOR_xorqi_ext_1_cc = 6257,
CODE_FOR_negqi2 = 6258,
CODE_FOR_neghi2 = 6259,
CODE_FOR_negsi2 = 6260,
CODE_FOR_negdi2 = 6261,
CODE_FOR_negti2 = 6262,
CODE_FOR_negvqi3 = 6263,
CODE_FOR_negvhi3 = 6264,
CODE_FOR_negvsi3 = 6265,
CODE_FOR_negvdi3 = 6266,
CODE_FOR_abssi2 = 6267,
CODE_FOR_absdi2 = 6268,
CODE_FOR_abstf2 = 6269,
CODE_FOR_negtf2 = 6270,
CODE_FOR_abssf2 = 6271,
CODE_FOR_negsf2 = 6272,
CODE_FOR_absdf2 = 6273,
CODE_FOR_negdf2 = 6274,
CODE_FOR_absxf2 = 6275,
CODE_FOR_negxf2 = 6276,
CODE_FOR_copysignsf3 = 6277,
CODE_FOR_copysigndf3 = 6278,
CODE_FOR_copysigntf3 = 6279,
CODE_FOR_xorsignsf3 = 6280,
CODE_FOR_xorsigndf3 = 6281,
CODE_FOR_one_cmplqi2 = 6282,
CODE_FOR_one_cmplhi2 = 6283,
CODE_FOR_one_cmplsi2 = 6284,
CODE_FOR_one_cmpldi2 = 6285,
CODE_FOR_ashlqi3 = 6286,
CODE_FOR_ashlhi3 = 6287,
CODE_FOR_ashlsi3 = 6288,
CODE_FOR_ashldi3 = 6289,
CODE_FOR_ashlti3 = 6290,
CODE_FOR_x86_shiftsi_adj_1 = 6291,
CODE_FOR_x86_shiftdi_adj_1 = 6292,
CODE_FOR_x86_shiftsi_adj_2 = 6293,
CODE_FOR_x86_shiftdi_adj_2 = 6294,
CODE_FOR_lshrqi3 = 6295,
CODE_FOR_ashrqi3 = 6296,
CODE_FOR_lshrhi3 = 6297,
CODE_FOR_ashrhi3 = 6298,
CODE_FOR_lshrsi3 = 6299,
CODE_FOR_ashrsi3 = 6300,
CODE_FOR_lshrdi3 = 6301,
CODE_FOR_ashrdi3 = 6302,
CODE_FOR_lshrti3 = 6303,
CODE_FOR_ashrti3 = 6304,
CODE_FOR_x86_shiftsi_adj_3 = 6305,
CODE_FOR_x86_shiftdi_adj_3 = 6306,
CODE_FOR_rotlti3 = 6307,
CODE_FOR_rotrti3 = 6308,
CODE_FOR_rotldi3 = 6309,
CODE_FOR_rotrdi3 = 6310,
CODE_FOR_rotlqi3 = 6311,
CODE_FOR_rotrqi3 = 6312,
CODE_FOR_rotlhi3 = 6313,
CODE_FOR_rotrhi3 = 6314,
CODE_FOR_rotlsi3 = 6315,
CODE_FOR_rotrsi3 = 6316,
CODE_FOR_indirect_jump = 6317,
CODE_FOR_tablejump = 6318,
CODE_FOR_call = 6319,
CODE_FOR_sibcall = 6320,
CODE_FOR_call_pop = 6321,
CODE_FOR_call_value = 6322,
CODE_FOR_sibcall_value = 6323,
CODE_FOR_call_value_pop = 6324,
CODE_FOR_untyped_call = 6325,
CODE_FOR_memory_blockage = 6326,
CODE_FOR_return = 6327,
CODE_FOR_simple_return = 6328,
CODE_FOR_simple_return_indirect_internal = 6329,
CODE_FOR_prologue = 6330,
CODE_FOR_set_got = 6331,
CODE_FOR_set_got_labelled = 6332,
CODE_FOR_epilogue = 6333,
CODE_FOR_sibcall_epilogue = 6334,
CODE_FOR_eh_return = 6335,
CODE_FOR_leave_si = 6336,
CODE_FOR_leave_di = 6337,
CODE_FOR_split_stack_prologue = 6338,
CODE_FOR_split_stack_space_check = 6339,
CODE_FOR_ffssi2 = 6340,
CODE_FOR_ffsdi2 = 6341,
CODE_FOR_clzsi2 = 6342,
CODE_FOR_clzdi2 = 6343,
CODE_FOR_bmi2_bzhi_si3 = 6344,
CODE_FOR_bmi2_bzhi_di3 = 6345,
CODE_FOR_tbm_bextri_si = 6346,
CODE_FOR_tbm_bextri_di = 6347,
CODE_FOR_bswapdi2 = 6348,
CODE_FOR_bswapsi2 = 6349,
CODE_FOR_bswaphi2 = 6350,
CODE_FOR_paritydi2 = 6351,
CODE_FOR_paritysi2 = 6352,
CODE_FOR_parityhi2 = 6353,
CODE_FOR_parityqi2 = 6354,
CODE_FOR_tls_global_dynamic_32 = 6355,
CODE_FOR_tls_global_dynamic_64_si = 6356,
CODE_FOR_tls_global_dynamic_64_di = 6357,
CODE_FOR_tls_local_dynamic_base_32 = 6358,
CODE_FOR_tls_local_dynamic_base_64_si = 6359,
CODE_FOR_tls_local_dynamic_base_64_di = 6360,
CODE_FOR_tls_dynamic_gnu2_32 = 6361,
CODE_FOR_tls_dynamic_gnu2_64_si = 6362,
CODE_FOR_tls_dynamic_gnu2_64_di = 6363,
CODE_FOR_rsqrtsf2 = 6364,
CODE_FOR_sqrtsf2 = 6365,
CODE_FOR_sqrtdf2 = 6366,
CODE_FOR_hypotsf3 = 6367,
CODE_FOR_hypotdf3 = 6368,
CODE_FOR_fmodxf3 = 6369,
CODE_FOR_fmodsf3 = 6370,
CODE_FOR_fmoddf3 = 6371,
CODE_FOR_remainderxf3 = 6372,
CODE_FOR_remaindersf3 = 6373,
CODE_FOR_remainderdf3 = 6374,
CODE_FOR_sinsf2 = 6375,
CODE_FOR_cossf2 = 6376,
CODE_FOR_sindf2 = 6377,
CODE_FOR_cosdf2 = 6378,
CODE_FOR_sincossf3 = 6379,
CODE_FOR_sincosdf3 = 6380,
CODE_FOR_tanxf2 = 6381,
CODE_FOR_tansf2 = 6382,
CODE_FOR_tandf2 = 6383,
CODE_FOR_atan2sf3 = 6384,
CODE_FOR_atan2df3 = 6385,
CODE_FOR_atanxf2 = 6386,
CODE_FOR_atansf2 = 6387,
CODE_FOR_atandf2 = 6388,
CODE_FOR_asinxf2 = 6389,
CODE_FOR_asinsf2 = 6390,
CODE_FOR_asindf2 = 6391,
CODE_FOR_acosxf2 = 6392,
CODE_FOR_acossf2 = 6393,
CODE_FOR_acosdf2 = 6394,
CODE_FOR_sinhxf2 = 6395,
CODE_FOR_sinhsf2 = 6396,
CODE_FOR_sinhdf2 = 6397,
CODE_FOR_coshxf2 = 6398,
CODE_FOR_coshsf2 = 6399,
CODE_FOR_coshdf2 = 6400,
CODE_FOR_tanhxf2 = 6401,
CODE_FOR_tanhsf2 = 6402,
CODE_FOR_tanhdf2 = 6403,
CODE_FOR_asinhxf2 = 6404,
CODE_FOR_asinhsf2 = 6405,
CODE_FOR_asinhdf2 = 6406,
CODE_FOR_acoshxf2 = 6407,
CODE_FOR_acoshsf2 = 6408,
CODE_FOR_acoshdf2 = 6409,
CODE_FOR_atanhxf2 = 6410,
CODE_FOR_atanhsf2 = 6411,
CODE_FOR_atanhdf2 = 6412,
CODE_FOR_logxf2 = 6413,
CODE_FOR_logsf2 = 6414,
CODE_FOR_logdf2 = 6415,
CODE_FOR_log10xf2 = 6416,
CODE_FOR_log10sf2 = 6417,
CODE_FOR_log10df2 = 6418,
CODE_FOR_log2xf2 = 6419,
CODE_FOR_log2sf2 = 6420,
CODE_FOR_log2df2 = 6421,
CODE_FOR_log1pxf2 = 6422,
CODE_FOR_log1psf2 = 6423,
CODE_FOR_log1pdf2 = 6424,
CODE_FOR_logbxf2 = 6425,
CODE_FOR_logbsf2 = 6426,
CODE_FOR_logbdf2 = 6427,
CODE_FOR_ilogbxf2 = 6428,
CODE_FOR_ilogbsf2 = 6429,
CODE_FOR_ilogbdf2 = 6430,
CODE_FOR_expNcorexf3 = 6431,
CODE_FOR_expxf2 = 6432,
CODE_FOR_expsf2 = 6433,
CODE_FOR_expdf2 = 6434,
CODE_FOR_exp10xf2 = 6435,
CODE_FOR_exp10sf2 = 6436,
CODE_FOR_exp10df2 = 6437,
CODE_FOR_exp2xf2 = 6438,
CODE_FOR_exp2sf2 = 6439,
CODE_FOR_exp2df2 = 6440,
CODE_FOR_expm1xf2 = 6441,
CODE_FOR_expm1sf2 = 6442,
CODE_FOR_expm1df2 = 6443,
CODE_FOR_ldexpxf3 = 6444,
CODE_FOR_ldexpsf3 = 6445,
CODE_FOR_ldexpdf3 = 6446,
CODE_FOR_scalbxf3 = 6447,
CODE_FOR_scalbsf3 = 6448,
CODE_FOR_scalbdf3 = 6449,
CODE_FOR_significandxf2 = 6450,
CODE_FOR_significandsf2 = 6451,
CODE_FOR_significanddf2 = 6452,
CODE_FOR_rintsf2 = 6453,
CODE_FOR_rintdf2 = 6454,
CODE_FOR_nearbyintxf2 = 6455,
CODE_FOR_nearbyintsf2 = 6456,
CODE_FOR_nearbyintdf2 = 6457,
CODE_FOR_roundsf2 = 6458,
CODE_FOR_rounddf2 = 6459,
CODE_FOR_roundxf2 = 6460,
CODE_FOR_lrintsfsi2 = 6461,
CODE_FOR_lrintsfdi2 = 6462,
CODE_FOR_lrintdfsi2 = 6463,
CODE_FOR_lrintdfdi2 = 6464,
CODE_FOR_lroundsfhi2 = 6465,
CODE_FOR_lrounddfhi2 = 6466,
CODE_FOR_lroundxfhi2 = 6467,
CODE_FOR_lroundsfsi2 = 6468,
CODE_FOR_lrounddfsi2 = 6469,
CODE_FOR_lroundxfsi2 = 6470,
CODE_FOR_lroundsfdi2 = 6471,
CODE_FOR_lrounddfdi2 = 6472,
CODE_FOR_lroundxfdi2 = 6473,
CODE_FOR_roundevenxf2 = 6474,
CODE_FOR_floorxf2 = 6475,
CODE_FOR_ceilxf2 = 6476,
CODE_FOR_btruncxf2 = 6477,
CODE_FOR_roundevensf2 = 6478,
CODE_FOR_floorsf2 = 6479,
CODE_FOR_ceilsf2 = 6480,
CODE_FOR_btruncsf2 = 6481,
CODE_FOR_roundevendf2 = 6482,
CODE_FOR_floordf2 = 6483,
CODE_FOR_ceildf2 = 6484,
CODE_FOR_btruncdf2 = 6485,
CODE_FOR_lfloorxfhi2 = 6486,
CODE_FOR_lceilxfhi2 = 6487,
CODE_FOR_lfloorxfsi2 = 6488,
CODE_FOR_lceilxfsi2 = 6489,
CODE_FOR_lfloorxfdi2 = 6490,
CODE_FOR_lceilxfdi2 = 6491,
CODE_FOR_lfloorsfsi2 = 6492,
CODE_FOR_lceilsfsi2 = 6493,
CODE_FOR_lfloorsfdi2 = 6494,
CODE_FOR_lceilsfdi2 = 6495,
CODE_FOR_lfloordfsi2 = 6496,
CODE_FOR_lceildfsi2 = 6497,
CODE_FOR_lfloordfdi2 = 6498,
CODE_FOR_lceildfdi2 = 6499,
CODE_FOR_signbittf2 = 6500,
CODE_FOR_signbitxf2 = 6501,
CODE_FOR_signbitdf2 = 6502,
CODE_FOR_signbitsf2 = 6503,
CODE_FOR_cpymemsi = 6504,
CODE_FOR_cpymemdi = 6505,
CODE_FOR_strmov = 6506,
CODE_FOR_strmov_singleop = 6507,
CODE_FOR_rep_mov = 6508,
CODE_FOR_setmemsi = 6509,
CODE_FOR_setmemdi = 6510,
CODE_FOR_strset = 6511,
CODE_FOR_strset_singleop = 6512,
CODE_FOR_rep_stos = 6513,
CODE_FOR_cmpstrnsi = 6514,
CODE_FOR_cmpintqi = 6515,
CODE_FOR_cmpstrnqi_nz_1 = 6516,
CODE_FOR_cmpstrnqi_1 = 6517,
CODE_FOR_strlensi = 6518,
CODE_FOR_strlendi = 6519,
CODE_FOR_strlenqi_1 = 6520,
CODE_FOR_movqicc = 6521,
CODE_FOR_movhicc = 6522,
CODE_FOR_movsicc = 6523,
CODE_FOR_movdicc = 6524,
CODE_FOR_x86_movsicc_0_m1 = 6525,
CODE_FOR_x86_movdicc_0_m1 = 6526,
CODE_FOR_movsfcc = 6527,
CODE_FOR_movdfcc = 6528,
CODE_FOR_movxfcc = 6529,
CODE_FOR_addqicc = 6530,
CODE_FOR_addhicc = 6531,
CODE_FOR_addsicc = 6532,
CODE_FOR_adddicc = 6533,
CODE_FOR_smaxhi3 = 6534,
CODE_FOR_sminhi3 = 6535,
CODE_FOR_umaxhi3 = 6536,
CODE_FOR_uminhi3 = 6537,
CODE_FOR_smaxsi3 = 6538,
CODE_FOR_sminsi3 = 6539,
CODE_FOR_umaxsi3 = 6540,
CODE_FOR_uminsi3 = 6541,
CODE_FOR_smaxdi3 = 6542,
CODE_FOR_smindi3 = 6543,
CODE_FOR_umaxdi3 = 6544,
CODE_FOR_umindi3 = 6545,
CODE_FOR_allocate_stack = 6546,
CODE_FOR_probe_stack = 6547,
CODE_FOR_builtin_setjmp_receiver = 6548,
CODE_FOR_save_stack_nonlocal = 6549,
CODE_FOR_restore_stack_nonlocal = 6550,
CODE_FOR_prefetch = 6551,
CODE_FOR_stack_protect_set = 6552,
CODE_FOR_stack_protect_test = 6553,
CODE_FOR_pause = 6554,
CODE_FOR_xbegin = 6555,
CODE_FOR_xtest = 6556,
CODE_FOR_rdpkru = 6557,
CODE_FOR_wrpkru = 6558,
CODE_FOR_movv8qi = 6559,
CODE_FOR_movv4hi = 6560,
CODE_FOR_movv2si = 6561,
CODE_FOR_movv1di = 6562,
CODE_FOR_movv2sf = 6563,
CODE_FOR_movmisalignv8qi = 6564,
CODE_FOR_movmisalignv4hi = 6565,
CODE_FOR_movmisalignv2si = 6566,
CODE_FOR_movmisalignv1di = 6567,
CODE_FOR_movmisalignv2sf = 6568,
CODE_FOR_absv2sf2 = 6569,
CODE_FOR_negv2sf2 = 6570,
CODE_FOR_mmx_addv2sf3 = 6571,
CODE_FOR_addv2sf3 = 6572,
CODE_FOR_mmx_subv2sf3 = 6573,
CODE_FOR_mmx_subrv2sf3 = 6574,
CODE_FOR_subv2sf3 = 6575,
CODE_FOR_mmx_mulv2sf3 = 6576,
CODE_FOR_mulv2sf3 = 6577,
CODE_FOR_mmx_smaxv2sf3 = 6578,
CODE_FOR_mmx_sminv2sf3 = 6579,
CODE_FOR_smaxv2sf3 = 6580,
CODE_FOR_sminv2sf3 = 6581,
CODE_FOR_mmx_haddv2sf3 = 6582,
CODE_FOR_mmx_haddsubv2sf3 = 6583,
CODE_FOR_mmx_eqv2sf3 = 6584,
CODE_FOR_copysignv2sf3 = 6585,
CODE_FOR_xorsignv2sf3 = 6586,
CODE_FOR_signbitv2sf2 = 6587,
CODE_FOR_fix_truncv2sfv2si2 = 6588,
CODE_FOR_floatv2siv2sf2 = 6589,
CODE_FOR_vec_setv2sf = 6590,
CODE_FOR_vec_extractv2sfsf = 6591,
CODE_FOR_vec_initv2sfsf = 6592,
CODE_FOR_mmx_addv8qi3 = 6593,
CODE_FOR_mmx_subv8qi3 = 6594,
CODE_FOR_mmx_addv4hi3 = 6595,
CODE_FOR_mmx_subv4hi3 = 6596,
CODE_FOR_mmx_addv2si3 = 6597,
CODE_FOR_mmx_subv2si3 = 6598,
CODE_FOR_mmx_addv1di3 = 6599,
CODE_FOR_mmx_subv1di3 = 6600,
CODE_FOR_addv8qi3 = 6601,
CODE_FOR_subv8qi3 = 6602,
CODE_FOR_addv4hi3 = 6603,
CODE_FOR_subv4hi3 = 6604,
CODE_FOR_addv2si3 = 6605,
CODE_FOR_subv2si3 = 6606,
CODE_FOR_mmx_ssaddv8qi3 = 6607,
CODE_FOR_mmx_usaddv8qi3 = 6608,
CODE_FOR_mmx_sssubv8qi3 = 6609,
CODE_FOR_mmx_ussubv8qi3 = 6610,
CODE_FOR_mmx_ssaddv4hi3 = 6611,
CODE_FOR_mmx_usaddv4hi3 = 6612,
CODE_FOR_mmx_sssubv4hi3 = 6613,
CODE_FOR_mmx_ussubv4hi3 = 6614,
CODE_FOR_mmx_mulv4hi3 = 6615,
CODE_FOR_mulv4hi3 = 6616,
CODE_FOR_mmx_smulv4hi3_highpart = 6617,
CODE_FOR_mmx_umulv4hi3_highpart = 6618,
CODE_FOR_mmx_pmaddwd = 6619,
CODE_FOR_mmx_pmulhrwv4hi3 = 6620,
CODE_FOR_sse2_umulv1siv1di3 = 6621,
CODE_FOR_mmx_smaxv4hi3 = 6622,
CODE_FOR_mmx_sminv4hi3 = 6623,
CODE_FOR_smaxv4hi3 = 6624,
CODE_FOR_sminv4hi3 = 6625,
CODE_FOR_mmx_umaxv8qi3 = 6626,
CODE_FOR_mmx_uminv8qi3 = 6627,
CODE_FOR_umaxv8qi3 = 6628,
CODE_FOR_uminv8qi3 = 6629,
CODE_FOR_ashrv4hi3 = 6630,
CODE_FOR_ashrv2si3 = 6631,
CODE_FOR_ashlv4hi3 = 6632,
CODE_FOR_lshrv4hi3 = 6633,
CODE_FOR_ashlv2si3 = 6634,
CODE_FOR_lshrv2si3 = 6635,
CODE_FOR_ashlv1di3 = 6636,
CODE_FOR_lshrv1di3 = 6637,
CODE_FOR_mmx_eqv8qi3 = 6638,
CODE_FOR_mmx_eqv4hi3 = 6639,
CODE_FOR_mmx_eqv2si3 = 6640,
CODE_FOR_one_cmplv8qi2 = 6641,
CODE_FOR_one_cmplv4hi2 = 6642,
CODE_FOR_one_cmplv2si2 = 6643,
CODE_FOR_mmx_andv8qi3 = 6644,
CODE_FOR_mmx_iorv8qi3 = 6645,
CODE_FOR_mmx_xorv8qi3 = 6646,
CODE_FOR_mmx_andv4hi3 = 6647,
CODE_FOR_mmx_iorv4hi3 = 6648,
CODE_FOR_mmx_xorv4hi3 = 6649,
CODE_FOR_mmx_andv2si3 = 6650,
CODE_FOR_mmx_iorv2si3 = 6651,
CODE_FOR_mmx_xorv2si3 = 6652,
CODE_FOR_andv8qi3 = 6653,
CODE_FOR_iorv8qi3 = 6654,
CODE_FOR_xorv8qi3 = 6655,
CODE_FOR_andv4hi3 = 6656,
CODE_FOR_iorv4hi3 = 6657,
CODE_FOR_xorv4hi3 = 6658,
CODE_FOR_andv2si3 = 6659,
CODE_FOR_iorv2si3 = 6660,
CODE_FOR_xorv2si3 = 6661,
CODE_FOR_mmx_pinsrw = 6662,
CODE_FOR_mmx_pshufw = 6663,
CODE_FOR_vec_setv2si = 6664,
CODE_FOR_vec_extractv2sisi = 6665,
CODE_FOR_vec_initv2sisi = 6666,
CODE_FOR_vec_setv4hi = 6667,
CODE_FOR_vec_extractv4hihi = 6668,
CODE_FOR_vec_initv4hihi = 6669,
CODE_FOR_vec_setv8qi = 6670,
CODE_FOR_vec_extractv8qiqi = 6671,
CODE_FOR_vec_initv8qiqi = 6672,
CODE_FOR_mmx_uavgv8qi3 = 6673,
CODE_FOR_mmx_uavgv4hi3 = 6674,
CODE_FOR_uavgv8qi3_ceil = 6675,
CODE_FOR_uavgv4hi3_ceil = 6676,
CODE_FOR_reduc_plus_scal_v8qi = 6677,
CODE_FOR_usadv8qi = 6678,
CODE_FOR_mmx_maskmovq = 6679,
CODE_FOR_mmx_emms = 6680,
CODE_FOR_mmx_femms = 6681,
CODE_FOR_movv64qi = 6682,
CODE_FOR_movv32qi = 6683,
CODE_FOR_movv16qi = 6684,
CODE_FOR_movv32hi = 6685,
CODE_FOR_movv16hi = 6686,
CODE_FOR_movv8hi = 6687,
CODE_FOR_movv16si = 6688,
CODE_FOR_movv8si = 6689,
CODE_FOR_movv4si = 6690,
CODE_FOR_movv8di = 6691,
CODE_FOR_movv4di = 6692,
CODE_FOR_movv2di = 6693,
CODE_FOR_movv4ti = 6694,
CODE_FOR_movv2ti = 6695,
CODE_FOR_movv1ti = 6696,
CODE_FOR_movv16sf = 6697,
CODE_FOR_movv8sf = 6698,
CODE_FOR_movv4sf = 6699,
CODE_FOR_movv8df = 6700,
CODE_FOR_movv4df = 6701,
CODE_FOR_movv2df = 6702,
CODE_FOR_avx512f_loadsf_mask = 6703,
CODE_FOR_avx512f_loaddf_mask = 6704,
CODE_FOR_avx512f_blendmv16si = 6705,
CODE_FOR_avx512vl_blendmv8si = 6706,
CODE_FOR_avx512vl_blendmv4si = 6707,
CODE_FOR_avx512f_blendmv8di = 6708,
CODE_FOR_avx512vl_blendmv4di = 6709,
CODE_FOR_avx512vl_blendmv2di = 6710,
CODE_FOR_avx512f_blendmv16sf = 6711,
CODE_FOR_avx512vl_blendmv8sf = 6712,
CODE_FOR_avx512vl_blendmv4sf = 6713,
CODE_FOR_avx512f_blendmv8df = 6714,
CODE_FOR_avx512vl_blendmv4df = 6715,
CODE_FOR_avx512vl_blendmv2df = 6716,
CODE_FOR_avx512bw_blendmv64qi = 6717,
CODE_FOR_avx512vl_blendmv16qi = 6718,
CODE_FOR_avx512vl_blendmv32qi = 6719,
CODE_FOR_avx512bw_blendmv32hi = 6720,
CODE_FOR_avx512vl_blendmv16hi = 6721,
CODE_FOR_avx512vl_blendmv8hi = 6722,
CODE_FOR_movmisalignv64qi = 6723,
CODE_FOR_movmisalignv32qi = 6724,
CODE_FOR_movmisalignv16qi = 6725,
CODE_FOR_movmisalignv32hi = 6726,
CODE_FOR_movmisalignv16hi = 6727,
CODE_FOR_movmisalignv8hi = 6728,
CODE_FOR_movmisalignv16si = 6729,
CODE_FOR_movmisalignv8si = 6730,
CODE_FOR_movmisalignv4si = 6731,
CODE_FOR_movmisalignv8di = 6732,
CODE_FOR_movmisalignv4di = 6733,
CODE_FOR_movmisalignv2di = 6734,
CODE_FOR_movmisalignv4ti = 6735,
CODE_FOR_movmisalignv2ti = 6736,
CODE_FOR_movmisalignv1ti = 6737,
CODE_FOR_movmisalignv16sf = 6738,
CODE_FOR_movmisalignv8sf = 6739,
CODE_FOR_movmisalignv4sf = 6740,
CODE_FOR_movmisalignv8df = 6741,
CODE_FOR_movmisalignv4df = 6742,
CODE_FOR_movmisalignv2df = 6743,
CODE_FOR_storentdi = 6744,
CODE_FOR_storentsi = 6745,
CODE_FOR_storentsf = 6746,
CODE_FOR_storentdf = 6747,
CODE_FOR_storentv8di = 6748,
CODE_FOR_storentv4di = 6749,
CODE_FOR_storentv2di = 6750,
CODE_FOR_storentv16sf = 6751,
CODE_FOR_storentv8sf = 6752,
CODE_FOR_storentv4sf = 6753,
CODE_FOR_storentv8df = 6754,
CODE_FOR_storentv4df = 6755,
CODE_FOR_storentv2df = 6756,
CODE_FOR_kmovb = 6757,
CODE_FOR_kmovw = 6758,
CODE_FOR_kmovd = 6759,
CODE_FOR_kmovq = 6760,
CODE_FOR_absv16sf2 = 6761,
CODE_FOR_negv16sf2 = 6762,
CODE_FOR_absv8sf2 = 6763,
CODE_FOR_negv8sf2 = 6764,
CODE_FOR_absv4sf2 = 6765,
CODE_FOR_negv4sf2 = 6766,
CODE_FOR_absv8df2 = 6767,
CODE_FOR_negv8df2 = 6768,
CODE_FOR_absv4df2 = 6769,
CODE_FOR_negv4df2 = 6770,
CODE_FOR_absv2df2 = 6771,
CODE_FOR_negv2df2 = 6772,
CODE_FOR_addv16sf3 = 6773,
CODE_FOR_addv16sf3_round = 6774,
CODE_FOR_addv16sf3_mask = 6775,
CODE_FOR_addv16sf3_mask_round = 6776,
CODE_FOR_subv16sf3 = 6777,
CODE_FOR_subv16sf3_round = 6778,
CODE_FOR_subv16sf3_mask = 6779,
CODE_FOR_subv16sf3_mask_round = 6780,
CODE_FOR_addv8sf3 = 6781,
CODE_FOR_addv8sf3_round = CODE_FOR_nothing,
CODE_FOR_addv8sf3_mask = 6782,
CODE_FOR_addv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv8sf3 = 6783,
CODE_FOR_subv8sf3_round = CODE_FOR_nothing,
CODE_FOR_subv8sf3_mask = 6784,
CODE_FOR_subv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_addv4sf3 = 6785,
CODE_FOR_addv4sf3_round = CODE_FOR_nothing,
CODE_FOR_addv4sf3_mask = 6786,
CODE_FOR_addv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv4sf3 = 6787,
CODE_FOR_subv4sf3_round = CODE_FOR_nothing,
CODE_FOR_subv4sf3_mask = 6788,
CODE_FOR_subv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_addv8df3 = 6789,
CODE_FOR_addv8df3_round = 6790,
CODE_FOR_addv8df3_mask = 6791,
CODE_FOR_addv8df3_mask_round = 6792,
CODE_FOR_subv8df3 = 6793,
CODE_FOR_subv8df3_round = 6794,
CODE_FOR_subv8df3_mask = 6795,
CODE_FOR_subv8df3_mask_round = 6796,
CODE_FOR_addv4df3 = 6797,
CODE_FOR_addv4df3_round = CODE_FOR_nothing,
CODE_FOR_addv4df3_mask = 6798,
CODE_FOR_addv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv4df3 = 6799,
CODE_FOR_subv4df3_round = CODE_FOR_nothing,
CODE_FOR_subv4df3_mask = 6800,
CODE_FOR_subv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_addv2df3 = 6801,
CODE_FOR_addv2df3_round = CODE_FOR_nothing,
CODE_FOR_addv2df3_mask = 6802,
CODE_FOR_addv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv2df3 = 6803,
CODE_FOR_subv2df3_round = CODE_FOR_nothing,
CODE_FOR_subv2df3_mask = 6804,
CODE_FOR_subv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv16sf3 = 6805,
CODE_FOR_mulv16sf3_round = 6806,
CODE_FOR_mulv16sf3_mask = 6807,
CODE_FOR_mulv16sf3_mask_round = 6808,
CODE_FOR_mulv8sf3 = 6809,
CODE_FOR_mulv8sf3_round = CODE_FOR_nothing,
CODE_FOR_mulv8sf3_mask = 6810,
CODE_FOR_mulv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv4sf3 = 6811,
CODE_FOR_mulv4sf3_round = CODE_FOR_nothing,
CODE_FOR_mulv4sf3_mask = 6812,
CODE_FOR_mulv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv8df3 = 6813,
CODE_FOR_mulv8df3_round = 6814,
CODE_FOR_mulv8df3_mask = 6815,
CODE_FOR_mulv8df3_mask_round = 6816,
CODE_FOR_mulv4df3 = 6817,
CODE_FOR_mulv4df3_round = CODE_FOR_nothing,
CODE_FOR_mulv4df3_mask = 6818,
CODE_FOR_mulv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv2df3 = 6819,
CODE_FOR_mulv2df3_round = CODE_FOR_nothing,
CODE_FOR_mulv2df3_mask = 6820,
CODE_FOR_mulv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_divv8df3 = 6821,
CODE_FOR_divv4df3 = 6822,
CODE_FOR_divv2df3 = 6823,
CODE_FOR_divv16sf3 = 6824,
CODE_FOR_divv8sf3 = 6825,
CODE_FOR_divv4sf3 = 6826,
CODE_FOR_sqrtv8df2 = 6827,
CODE_FOR_sqrtv4df2 = 6828,
CODE_FOR_sqrtv2df2 = 6829,
CODE_FOR_sqrtv16sf2 = 6830,
CODE_FOR_sqrtv8sf2 = 6831,
CODE_FOR_sqrtv4sf2 = 6832,
CODE_FOR_rsqrtv16sf2 = 6833,
CODE_FOR_rsqrtv8sf2 = 6834,
CODE_FOR_rsqrtv4sf2 = 6835,
CODE_FOR_smaxv16sf3 = 6836,
CODE_FOR_smaxv16sf3_round = 6837,
CODE_FOR_smaxv16sf3_mask = 6838,
CODE_FOR_smaxv16sf3_mask_round = 6839,
CODE_FOR_sminv16sf3 = 6840,
CODE_FOR_sminv16sf3_round = 6841,
CODE_FOR_sminv16sf3_mask = 6842,
CODE_FOR_sminv16sf3_mask_round = 6843,
CODE_FOR_smaxv8sf3 = 6844,
CODE_FOR_smaxv8sf3_round = CODE_FOR_nothing,
CODE_FOR_smaxv8sf3_mask = 6845,
CODE_FOR_smaxv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv8sf3 = 6846,
CODE_FOR_sminv8sf3_round = CODE_FOR_nothing,
CODE_FOR_sminv8sf3_mask = 6847,
CODE_FOR_sminv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_smaxv4sf3 = 6848,
CODE_FOR_smaxv4sf3_round = CODE_FOR_nothing,
CODE_FOR_smaxv4sf3_mask = 6849,
CODE_FOR_smaxv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv4sf3 = 6850,
CODE_FOR_sminv4sf3_round = CODE_FOR_nothing,
CODE_FOR_sminv4sf3_mask = 6851,
CODE_FOR_sminv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_smaxv8df3 = 6852,
CODE_FOR_smaxv8df3_round = 6853,
CODE_FOR_smaxv8df3_mask = 6854,
CODE_FOR_smaxv8df3_mask_round = 6855,
CODE_FOR_sminv8df3 = 6856,
CODE_FOR_sminv8df3_round = 6857,
CODE_FOR_sminv8df3_mask = 6858,
CODE_FOR_sminv8df3_mask_round = 6859,
CODE_FOR_smaxv4df3 = 6860,
CODE_FOR_smaxv4df3_round = CODE_FOR_nothing,
CODE_FOR_smaxv4df3_mask = 6861,
CODE_FOR_smaxv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv4df3 = 6862,
CODE_FOR_sminv4df3_round = CODE_FOR_nothing,
CODE_FOR_sminv4df3_mask = 6863,
CODE_FOR_sminv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_smaxv2df3 = 6864,
CODE_FOR_smaxv2df3_round = CODE_FOR_nothing,
CODE_FOR_smaxv2df3_mask = 6865,
CODE_FOR_smaxv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv2df3 = 6866,
CODE_FOR_sminv2df3_round = CODE_FOR_nothing,
CODE_FOR_sminv2df3_mask = 6867,
CODE_FOR_sminv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse3_haddv2df3 = 6868,
CODE_FOR_reduc_plus_scal_v2df = 6869,
CODE_FOR_reduc_plus_scal_v4sf = 6870,
CODE_FOR_reduc_plus_scal_v16qi = 6871,
CODE_FOR_reduc_plus_scal_v4df = 6872,
CODE_FOR_reduc_plus_scal_v8sf = 6873,
CODE_FOR_reduc_plus_scal_v8df = 6874,
CODE_FOR_reduc_plus_scal_v16sf = 6875,
CODE_FOR_reduc_plus_scal_v32qi = 6876,
CODE_FOR_reduc_plus_scal_v64qi = 6877,
CODE_FOR_reduc_smax_scal_v4sf = 6878,
CODE_FOR_reduc_smin_scal_v4sf = 6879,
CODE_FOR_reduc_smax_scal_v2df = 6880,
CODE_FOR_reduc_smin_scal_v2df = 6881,
CODE_FOR_reduc_smax_scal_v4si = 6882,
CODE_FOR_reduc_smin_scal_v4si = 6883,
CODE_FOR_reduc_smax_scal_v8hi = 6884,
CODE_FOR_reduc_smin_scal_v8hi = 6885,
CODE_FOR_reduc_smax_scal_v16qi = 6886,
CODE_FOR_reduc_smin_scal_v16qi = 6887,
CODE_FOR_reduc_smax_scal_v2di = 6888,
CODE_FOR_reduc_smin_scal_v2di = 6889,
CODE_FOR_reduc_smax_scal_v32qi = 6890,
CODE_FOR_reduc_smin_scal_v32qi = 6891,
CODE_FOR_reduc_smax_scal_v16hi = 6892,
CODE_FOR_reduc_smin_scal_v16hi = 6893,
CODE_FOR_reduc_smax_scal_v8si = 6894,
CODE_FOR_reduc_smin_scal_v8si = 6895,
CODE_FOR_reduc_smax_scal_v4di = 6896,
CODE_FOR_reduc_smin_scal_v4di = 6897,
CODE_FOR_reduc_smax_scal_v8sf = 6898,
CODE_FOR_reduc_smin_scal_v8sf = 6899,
CODE_FOR_reduc_smax_scal_v4df = 6900,
CODE_FOR_reduc_smin_scal_v4df = 6901,
CODE_FOR_reduc_smax_scal_v64qi = 6902,
CODE_FOR_reduc_smin_scal_v64qi = 6903,
CODE_FOR_reduc_smax_scal_v32hi = 6904,
CODE_FOR_reduc_smin_scal_v32hi = 6905,
CODE_FOR_reduc_smax_scal_v16si = 6906,
CODE_FOR_reduc_smin_scal_v16si = 6907,
CODE_FOR_reduc_smax_scal_v8di = 6908,
CODE_FOR_reduc_smin_scal_v8di = 6909,
CODE_FOR_reduc_smax_scal_v16sf = 6910,
CODE_FOR_reduc_smin_scal_v16sf = 6911,
CODE_FOR_reduc_smax_scal_v8df = 6912,
CODE_FOR_reduc_smin_scal_v8df = 6913,
CODE_FOR_reduc_umax_scal_v16si = 6914,
CODE_FOR_reduc_umin_scal_v16si = 6915,
CODE_FOR_reduc_umax_scal_v8di = 6916,
CODE_FOR_reduc_umin_scal_v8di = 6917,
CODE_FOR_reduc_umax_scal_v32hi = 6918,
CODE_FOR_reduc_umin_scal_v32hi = 6919,
CODE_FOR_reduc_umax_scal_v64qi = 6920,
CODE_FOR_reduc_umin_scal_v64qi = 6921,
CODE_FOR_reduc_umax_scal_v32qi = 6922,
CODE_FOR_reduc_umin_scal_v32qi = 6923,
CODE_FOR_reduc_umax_scal_v16hi = 6924,
CODE_FOR_reduc_umin_scal_v16hi = 6925,
CODE_FOR_reduc_umax_scal_v8si = 6926,
CODE_FOR_reduc_umin_scal_v8si = 6927,
CODE_FOR_reduc_umax_scal_v4di = 6928,
CODE_FOR_reduc_umin_scal_v4di = 6929,
CODE_FOR_reduc_umin_scal_v8hi = 6930,
CODE_FOR_vec_cmpv16sihi = 6931,
CODE_FOR_vec_cmpv8siqi = 6932,
CODE_FOR_vec_cmpv4siqi = 6933,
CODE_FOR_vec_cmpv8diqi = 6934,
CODE_FOR_vec_cmpv4diqi = 6935,
CODE_FOR_vec_cmpv2diqi = 6936,
CODE_FOR_vec_cmpv16sfhi = 6937,
CODE_FOR_vec_cmpv8sfqi = 6938,
CODE_FOR_vec_cmpv4sfqi = 6939,
CODE_FOR_vec_cmpv8dfqi = 6940,
CODE_FOR_vec_cmpv4dfqi = 6941,
CODE_FOR_vec_cmpv2dfqi = 6942,
CODE_FOR_vec_cmpv64qidi = 6943,
CODE_FOR_vec_cmpv16qihi = 6944,
CODE_FOR_vec_cmpv32qisi = 6945,
CODE_FOR_vec_cmpv32hisi = 6946,
CODE_FOR_vec_cmpv16hihi = 6947,
CODE_FOR_vec_cmpv8hiqi = 6948,
CODE_FOR_vec_cmpv32qiv32qi = 6949,
CODE_FOR_vec_cmpv16hiv16hi = 6950,
CODE_FOR_vec_cmpv8siv8si = 6951,
CODE_FOR_vec_cmpv4div4di = 6952,
CODE_FOR_vec_cmpv16qiv16qi = 6953,
CODE_FOR_vec_cmpv8hiv8hi = 6954,
CODE_FOR_vec_cmpv4siv4si = 6955,
CODE_FOR_vec_cmpv2div2di = 6956,
CODE_FOR_vec_cmpv8sfv8si = 6957,
CODE_FOR_vec_cmpv4dfv4di = 6958,
CODE_FOR_vec_cmpv4sfv4si = 6959,
CODE_FOR_vec_cmpv2dfv2di = 6960,
CODE_FOR_vec_cmpuv16sihi = 6961,
CODE_FOR_vec_cmpuv8siqi = 6962,
CODE_FOR_vec_cmpuv4siqi = 6963,
CODE_FOR_vec_cmpuv8diqi = 6964,
CODE_FOR_vec_cmpuv4diqi = 6965,
CODE_FOR_vec_cmpuv2diqi = 6966,
CODE_FOR_vec_cmpuv64qidi = 6967,
CODE_FOR_vec_cmpuv16qihi = 6968,
CODE_FOR_vec_cmpuv32qisi = 6969,
CODE_FOR_vec_cmpuv32hisi = 6970,
CODE_FOR_vec_cmpuv16hihi = 6971,
CODE_FOR_vec_cmpuv8hiqi = 6972,
CODE_FOR_vec_cmpuv32qiv32qi = 6973,
CODE_FOR_vec_cmpuv16hiv16hi = 6974,
CODE_FOR_vec_cmpuv8siv8si = 6975,
CODE_FOR_vec_cmpuv4div4di = 6976,
CODE_FOR_vec_cmpuv16qiv16qi = 6977,
CODE_FOR_vec_cmpuv8hiv8hi = 6978,
CODE_FOR_vec_cmpuv4siv4si = 6979,
CODE_FOR_vec_cmpuv2div2di = 6980,
CODE_FOR_vec_cmpeqv2div2di = 6981,
CODE_FOR_vcondv64qiv16sf = 6982,
CODE_FOR_vcondv32hiv16sf = 6983,
CODE_FOR_vcondv16siv16sf = 6984,
CODE_FOR_vcondv8div16sf = 6985,
CODE_FOR_vcondv16sfv16sf = 6986,
CODE_FOR_vcondv8dfv16sf = 6987,
CODE_FOR_vcondv64qiv8df = 6988,
CODE_FOR_vcondv32hiv8df = 6989,
CODE_FOR_vcondv16siv8df = 6990,
CODE_FOR_vcondv8div8df = 6991,
CODE_FOR_vcondv16sfv8df = 6992,
CODE_FOR_vcondv8dfv8df = 6993,
CODE_FOR_vcondv32qiv8sf = 6994,
CODE_FOR_vcondv16hiv8sf = 6995,
CODE_FOR_vcondv8siv8sf = 6996,
CODE_FOR_vcondv4div8sf = 6997,
CODE_FOR_vcondv8sfv8sf = 6998,
CODE_FOR_vcondv4dfv8sf = 6999,
CODE_FOR_vcondv32qiv4df = 7000,
CODE_FOR_vcondv16hiv4df = 7001,
CODE_FOR_vcondv8siv4df = 7002,
CODE_FOR_vcondv4div4df = 7003,
CODE_FOR_vcondv8sfv4df = 7004,
CODE_FOR_vcondv4dfv4df = 7005,
CODE_FOR_vcondv16qiv4sf = 7006,
CODE_FOR_vcondv16qiv2df = 7007,
CODE_FOR_vcondv8hiv4sf = 7008,
CODE_FOR_vcondv8hiv2df = 7009,
CODE_FOR_vcondv4siv4sf = 7010,
CODE_FOR_vcondv4siv2df = 7011,
CODE_FOR_vcondv2div4sf = 7012,
CODE_FOR_vcondv2div2df = 7013,
CODE_FOR_vcondv4sfv4sf = 7014,
CODE_FOR_vcondv4sfv2df = 7015,
CODE_FOR_vcondv2dfv4sf = 7016,
CODE_FOR_vcondv2dfv2df = 7017,
CODE_FOR_vcond_mask_v16sihi = 7018,
CODE_FOR_vcond_mask_v8siqi = 7019,
CODE_FOR_vcond_mask_v4siqi = 7020,
CODE_FOR_vcond_mask_v8diqi = 7021,
CODE_FOR_vcond_mask_v4diqi = 7022,
CODE_FOR_vcond_mask_v2diqi = 7023,
CODE_FOR_vcond_mask_v16sfhi = 7024,
CODE_FOR_vcond_mask_v8sfqi = 7025,
CODE_FOR_vcond_mask_v4sfqi = 7026,
CODE_FOR_vcond_mask_v8dfqi = 7027,
CODE_FOR_vcond_mask_v4dfqi = 7028,
CODE_FOR_vcond_mask_v2dfqi = 7029,
CODE_FOR_vcond_mask_v64qidi = 7030,
CODE_FOR_vcond_mask_v16qihi = 7031,
CODE_FOR_vcond_mask_v32qisi = 7032,
CODE_FOR_vcond_mask_v32hisi = 7033,
CODE_FOR_vcond_mask_v16hihi = 7034,
CODE_FOR_vcond_mask_v8hiqi = 7035,
CODE_FOR_vcond_mask_v32qiv32qi = 7036,
CODE_FOR_vcond_mask_v16hiv16hi = 7037,
CODE_FOR_vcond_mask_v8siv8si = 7038,
CODE_FOR_vcond_mask_v4div4di = 7039,
CODE_FOR_vcond_mask_v16qiv16qi = 7040,
CODE_FOR_vcond_mask_v8hiv8hi = 7041,
CODE_FOR_vcond_mask_v4siv4si = 7042,
CODE_FOR_vcond_mask_v2div2di = 7043,
CODE_FOR_vcond_mask_v8sfv8si = 7044,
CODE_FOR_vcond_mask_v4dfv4di = 7045,
CODE_FOR_vcond_mask_v4sfv4si = 7046,
CODE_FOR_vcond_mask_v2dfv2di = 7047,
CODE_FOR_andv8sf3 = 7048,
CODE_FOR_andv8sf3_mask = 7049,
CODE_FOR_iorv8sf3 = 7050,
CODE_FOR_iorv8sf3_mask = 7051,
CODE_FOR_xorv8sf3 = 7052,
CODE_FOR_xorv8sf3_mask = 7053,
CODE_FOR_andv4sf3 = 7054,
CODE_FOR_andv4sf3_mask = 7055,
CODE_FOR_iorv4sf3 = 7056,
CODE_FOR_iorv4sf3_mask = 7057,
CODE_FOR_xorv4sf3 = 7058,
CODE_FOR_xorv4sf3_mask = 7059,
CODE_FOR_andv4df3 = 7060,
CODE_FOR_andv4df3_mask = 7061,
CODE_FOR_iorv4df3 = 7062,
CODE_FOR_iorv4df3_mask = 7063,
CODE_FOR_xorv4df3 = 7064,
CODE_FOR_xorv4df3_mask = 7065,
CODE_FOR_andv2df3 = 7066,
CODE_FOR_andv2df3_mask = 7067,
CODE_FOR_iorv2df3 = 7068,
CODE_FOR_iorv2df3_mask = 7069,
CODE_FOR_xorv2df3 = 7070,
CODE_FOR_xorv2df3_mask = 7071,
CODE_FOR_andv16sf3 = 7072,
CODE_FOR_andv16sf3_mask = 7073,
CODE_FOR_iorv16sf3 = 7074,
CODE_FOR_iorv16sf3_mask = 7075,
CODE_FOR_xorv16sf3 = 7076,
CODE_FOR_xorv16sf3_mask = 7077,
CODE_FOR_andv8df3 = 7078,
CODE_FOR_andv8df3_mask = 7079,
CODE_FOR_iorv8df3 = 7080,
CODE_FOR_iorv8df3_mask = 7081,
CODE_FOR_xorv8df3 = 7082,
CODE_FOR_xorv8df3_mask = 7083,
CODE_FOR_copysignv16sf3 = 7084,
CODE_FOR_copysignv8sf3 = 7085,
CODE_FOR_copysignv4sf3 = 7086,
CODE_FOR_copysignv8df3 = 7087,
CODE_FOR_copysignv4df3 = 7088,
CODE_FOR_copysignv2df3 = 7089,
CODE_FOR_xorsignv16sf3 = 7090,
CODE_FOR_xorsignv8sf3 = 7091,
CODE_FOR_xorsignv4sf3 = 7092,
CODE_FOR_xorsignv8df3 = 7093,
CODE_FOR_xorsignv4df3 = 7094,
CODE_FOR_xorsignv2df3 = 7095,
CODE_FOR_signbitv16sf2 = 7096,
CODE_FOR_signbitv8sf2 = 7097,
CODE_FOR_signbitv4sf2 = 7098,
CODE_FOR_andtf3 = 7099,
CODE_FOR_iortf3 = 7100,
CODE_FOR_xortf3 = 7101,
CODE_FOR_fmasf4 = 7102,
CODE_FOR_fmadf4 = 7103,
CODE_FOR_fmav4sf4 = 7104,
CODE_FOR_fmav2df4 = 7105,
CODE_FOR_fmav8sf4 = 7106,
CODE_FOR_fmav4df4 = 7107,
CODE_FOR_fmav16sf4 = 7108,
CODE_FOR_fmav8df4 = 7109,
CODE_FOR_fmssf4 = 7110,
CODE_FOR_fmsdf4 = 7111,
CODE_FOR_fmsv4sf4 = 7112,
CODE_FOR_fmsv2df4 = 7113,
CODE_FOR_fmsv8sf4 = 7114,
CODE_FOR_fmsv4df4 = 7115,
CODE_FOR_fmsv16sf4 = 7116,
CODE_FOR_fmsv8df4 = 7117,
CODE_FOR_fnmasf4 = 7118,
CODE_FOR_fnmadf4 = 7119,
CODE_FOR_fnmav4sf4 = 7120,
CODE_FOR_fnmav2df4 = 7121,
CODE_FOR_fnmav8sf4 = 7122,
CODE_FOR_fnmav4df4 = 7123,
CODE_FOR_fnmav16sf4 = 7124,
CODE_FOR_fnmav8df4 = 7125,
CODE_FOR_fnmssf4 = 7126,
CODE_FOR_fnmsdf4 = 7127,
CODE_FOR_fnmsv4sf4 = 7128,
CODE_FOR_fnmsv2df4 = 7129,
CODE_FOR_fnmsv8sf4 = 7130,
CODE_FOR_fnmsv4df4 = 7131,
CODE_FOR_fnmsv16sf4 = 7132,
CODE_FOR_fnmsv8df4 = 7133,
CODE_FOR_fma4i_fmadd_sf = 7134,
CODE_FOR_fma4i_fmadd_df = 7135,
CODE_FOR_fma4i_fmadd_v4sf = 7136,
CODE_FOR_fma4i_fmadd_v2df = 7137,
CODE_FOR_fma4i_fmadd_v8sf = 7138,
CODE_FOR_fma4i_fmadd_v4df = 7139,
CODE_FOR_fma4i_fmadd_v16sf = 7140,
CODE_FOR_fma4i_fmadd_v8df = 7141,
CODE_FOR_fma4i_fmsub_sf = 7142,
CODE_FOR_fma4i_fmsub_df = 7143,
CODE_FOR_fma4i_fmsub_v4sf = 7144,
CODE_FOR_fma4i_fmsub_v2df = 7145,
CODE_FOR_fma4i_fmsub_v8sf = 7146,
CODE_FOR_fma4i_fmsub_v4df = 7147,
CODE_FOR_fma4i_fmsub_v16sf = 7148,
CODE_FOR_fma4i_fmsub_v8df = 7149,
CODE_FOR_fma4i_fnmadd_sf = 7150,
CODE_FOR_fma4i_fnmadd_df = 7151,
CODE_FOR_fma4i_fnmadd_v4sf = 7152,
CODE_FOR_fma4i_fnmadd_v2df = 7153,
CODE_FOR_fma4i_fnmadd_v8sf = 7154,
CODE_FOR_fma4i_fnmadd_v4df = 7155,
CODE_FOR_fma4i_fnmadd_v16sf = 7156,
CODE_FOR_fma4i_fnmadd_v8df = 7157,
CODE_FOR_fma4i_fnmsub_sf = 7158,
CODE_FOR_fma4i_fnmsub_df = 7159,
CODE_FOR_fma4i_fnmsub_v4sf = 7160,
CODE_FOR_fma4i_fnmsub_v2df = 7161,
CODE_FOR_fma4i_fnmsub_v8sf = 7162,
CODE_FOR_fma4i_fnmsub_v4df = 7163,
CODE_FOR_fma4i_fnmsub_v16sf = 7164,
CODE_FOR_fma4i_fnmsub_v8df = 7165,
CODE_FOR_avx512f_fmadd_v16sf_maskz = 7166,
CODE_FOR_avx512f_fmadd_v16sf_maskz_round = 7167,
CODE_FOR_avx512vl_fmadd_v8sf_maskz = 7168,
CODE_FOR_avx512vl_fmadd_v8sf_maskz_round = 7169,
CODE_FOR_avx512vl_fmadd_v4sf_maskz = 7170,
CODE_FOR_avx512vl_fmadd_v4sf_maskz_round = 7171,
CODE_FOR_avx512f_fmadd_v8df_maskz = 7172,
CODE_FOR_avx512f_fmadd_v8df_maskz_round = 7173,
CODE_FOR_avx512vl_fmadd_v4df_maskz = 7174,
CODE_FOR_avx512vl_fmadd_v4df_maskz_round = 7175,
CODE_FOR_avx512vl_fmadd_v2df_maskz = 7176,
CODE_FOR_avx512vl_fmadd_v2df_maskz_round = 7177,
CODE_FOR_avx512f_fmsub_v16sf_maskz = 7178,
CODE_FOR_avx512f_fmsub_v16sf_maskz_round = 7179,
CODE_FOR_avx512vl_fmsub_v8sf_maskz = 7180,
CODE_FOR_avx512vl_fmsub_v8sf_maskz_round = 7181,
CODE_FOR_avx512vl_fmsub_v4sf_maskz = 7182,
CODE_FOR_avx512vl_fmsub_v4sf_maskz_round = 7183,
CODE_FOR_avx512f_fmsub_v8df_maskz = 7184,
CODE_FOR_avx512f_fmsub_v8df_maskz_round = 7185,
CODE_FOR_avx512vl_fmsub_v4df_maskz = 7186,
CODE_FOR_avx512vl_fmsub_v4df_maskz_round = 7187,
CODE_FOR_avx512vl_fmsub_v2df_maskz = 7188,
CODE_FOR_avx512vl_fmsub_v2df_maskz_round = 7189,
CODE_FOR_avx512f_fnmadd_v16sf_maskz = 7190,
CODE_FOR_avx512f_fnmadd_v16sf_maskz_round = 7191,
CODE_FOR_avx512vl_fnmadd_v8sf_maskz = 7192,
CODE_FOR_avx512vl_fnmadd_v8sf_maskz_round = 7193,
CODE_FOR_avx512vl_fnmadd_v4sf_maskz = 7194,
CODE_FOR_avx512vl_fnmadd_v4sf_maskz_round = 7195,
CODE_FOR_avx512f_fnmadd_v8df_maskz = 7196,
CODE_FOR_avx512f_fnmadd_v8df_maskz_round = 7197,
CODE_FOR_avx512vl_fnmadd_v4df_maskz = 7198,
CODE_FOR_avx512vl_fnmadd_v4df_maskz_round = 7199,
CODE_FOR_avx512vl_fnmadd_v2df_maskz = 7200,
CODE_FOR_avx512vl_fnmadd_v2df_maskz_round = 7201,
CODE_FOR_avx512f_fnmsub_v16sf_maskz = 7202,
CODE_FOR_avx512f_fnmsub_v16sf_maskz_round = 7203,
CODE_FOR_avx512vl_fnmsub_v8sf_maskz = 7204,
CODE_FOR_avx512vl_fnmsub_v8sf_maskz_round = 7205,
CODE_FOR_avx512vl_fnmsub_v4sf_maskz = 7206,
CODE_FOR_avx512vl_fnmsub_v4sf_maskz_round = 7207,
CODE_FOR_avx512f_fnmsub_v8df_maskz = 7208,
CODE_FOR_avx512f_fnmsub_v8df_maskz_round = 7209,
CODE_FOR_avx512vl_fnmsub_v4df_maskz = 7210,
CODE_FOR_avx512vl_fnmsub_v4df_maskz_round = 7211,
CODE_FOR_avx512vl_fnmsub_v2df_maskz = 7212,
CODE_FOR_avx512vl_fnmsub_v2df_maskz_round = 7213,
CODE_FOR_fmaddsub_v16sf = 7214,
CODE_FOR_fmaddsub_v8sf = 7215,
CODE_FOR_fmaddsub_v4sf = 7216,
CODE_FOR_fmaddsub_v8df = 7217,
CODE_FOR_fmaddsub_v4df = 7218,
CODE_FOR_fmaddsub_v2df = 7219,
CODE_FOR_avx512f_fmaddsub_v16sf_maskz = 7220,
CODE_FOR_avx512f_fmaddsub_v16sf_maskz_round = 7221,
CODE_FOR_avx512vl_fmaddsub_v8sf_maskz = 7222,
CODE_FOR_avx512vl_fmaddsub_v8sf_maskz_round = 7223,
CODE_FOR_avx512vl_fmaddsub_v4sf_maskz = 7224,
CODE_FOR_avx512vl_fmaddsub_v4sf_maskz_round = 7225,
CODE_FOR_avx512f_fmaddsub_v8df_maskz = 7226,
CODE_FOR_avx512f_fmaddsub_v8df_maskz_round = 7227,
CODE_FOR_avx512vl_fmaddsub_v4df_maskz = 7228,
CODE_FOR_avx512vl_fmaddsub_v4df_maskz_round = 7229,
CODE_FOR_avx512vl_fmaddsub_v2df_maskz = 7230,
CODE_FOR_avx512vl_fmaddsub_v2df_maskz_round = 7231,
CODE_FOR_fmai_vmfmadd_v4sf = 7232,
CODE_FOR_fmai_vmfmadd_v4sf_round = 7233,
CODE_FOR_fmai_vmfmadd_v2df = 7234,
CODE_FOR_fmai_vmfmadd_v2df_round = 7235,
CODE_FOR_fmai_vmfmsub_v4sf = 7236,
CODE_FOR_fmai_vmfmsub_v4sf_round = 7237,
CODE_FOR_fmai_vmfmsub_v2df = 7238,
CODE_FOR_fmai_vmfmsub_v2df_round = 7239,
CODE_FOR_fmai_vmfnmadd_v4sf = 7240,
CODE_FOR_fmai_vmfnmadd_v4sf_round = 7241,
CODE_FOR_fmai_vmfnmadd_v2df = 7242,
CODE_FOR_fmai_vmfnmadd_v2df_round = 7243,
CODE_FOR_fmai_vmfnmsub_v4sf = 7244,
CODE_FOR_fmai_vmfnmsub_v4sf_round = 7245,
CODE_FOR_fmai_vmfnmsub_v2df = 7246,
CODE_FOR_fmai_vmfnmsub_v2df_round = 7247,
CODE_FOR_avx512f_vmfmadd_v4sf_maskz = 7248,
CODE_FOR_avx512f_vmfmadd_v4sf_maskz_round = 7249,
CODE_FOR_avx512f_vmfmadd_v2df_maskz = 7250,
CODE_FOR_avx512f_vmfmadd_v2df_maskz_round = 7251,
CODE_FOR_fma4i_vmfmadd_v4sf = 7252,
CODE_FOR_fma4i_vmfmadd_v2df = 7253,
CODE_FOR_floatunsv16siv16sf2 = 7254,
CODE_FOR_floatunsv8siv8sf2 = 7255,
CODE_FOR_floatunsv4siv4sf2 = 7256,
CODE_FOR_fixuns_truncv16sfv16si2 = 7257,
CODE_FOR_fixuns_truncv8sfv8si2 = 7258,
CODE_FOR_fixuns_truncv4sfv4si2 = 7259,
CODE_FOR_floatv2siv2df2 = 7260,
CODE_FOR_fix_truncv2dfv2si2 = 7261,
CODE_FOR_avx512dq_floatv2div2sf2 = 7262,
CODE_FOR_avx512dq_floatunsv2div2sf2 = 7263,
CODE_FOR_floatv2div2sf2 = 7264,
CODE_FOR_floatunsv2div2sf2 = 7265,
CODE_FOR_vec_packs_float_v8di = 7266,
CODE_FOR_vec_packu_float_v8di = 7267,
CODE_FOR_vec_packs_float_v4di = 7268,
CODE_FOR_vec_packu_float_v4di = 7269,
CODE_FOR_vec_packs_float_v2di = 7270,
CODE_FOR_vec_packu_float_v2di = 7271,
CODE_FOR_floatv2div2sf2_mask = 7272,
CODE_FOR_floatunsv2div2sf2_mask = 7273,
CODE_FOR_avx_cvtpd2dq256_2 = 7274,
CODE_FOR_fix_truncv2sfv2di2 = 7275,
CODE_FOR_fixuns_truncv2sfv2di2 = 7276,
CODE_FOR_vec_unpack_sfix_trunc_lo_v16sf = 7277,
CODE_FOR_vec_unpack_ufix_trunc_lo_v16sf = 7278,
CODE_FOR_vec_unpack_sfix_trunc_lo_v8sf = 7279,
CODE_FOR_vec_unpack_ufix_trunc_lo_v8sf = 7280,
CODE_FOR_vec_unpack_sfix_trunc_lo_v4sf = 7281,
CODE_FOR_vec_unpack_ufix_trunc_lo_v4sf = 7282,
CODE_FOR_vec_unpack_sfix_trunc_hi_v16sf = 7283,
CODE_FOR_vec_unpack_ufix_trunc_hi_v16sf = 7284,
CODE_FOR_vec_unpack_sfix_trunc_hi_v8sf = 7285,
CODE_FOR_vec_unpack_ufix_trunc_hi_v8sf = 7286,
CODE_FOR_vec_unpack_sfix_trunc_hi_v4sf = 7287,
CODE_FOR_vec_unpack_ufix_trunc_hi_v4sf = 7288,
CODE_FOR_avx_cvttpd2dq256_2 = 7289,
CODE_FOR_sse2_cvtpd2ps = 7290,
CODE_FOR_sse2_cvtpd2ps_mask = 7291,
CODE_FOR_truncv8dfv8sf2 = 7292,
CODE_FOR_truncv4dfv4sf2 = 7293,
CODE_FOR_extendv8sfv8df2 = 7294,
CODE_FOR_extendv4sfv4df2 = 7295,
CODE_FOR_avx512bw_cvtmask2bv64qi = 7296,
CODE_FOR_avx512vl_cvtmask2bv16qi = 7297,
CODE_FOR_avx512vl_cvtmask2bv32qi = 7298,
CODE_FOR_avx512bw_cvtmask2wv32hi = 7299,
CODE_FOR_avx512vl_cvtmask2wv16hi = 7300,
CODE_FOR_avx512vl_cvtmask2wv8hi = 7301,
CODE_FOR_avx512f_cvtmask2dv16si = 7302,
CODE_FOR_avx512vl_cvtmask2dv8si = 7303,
CODE_FOR_avx512vl_cvtmask2dv4si = 7304,
CODE_FOR_avx512f_cvtmask2qv8di = 7305,
CODE_FOR_avx512vl_cvtmask2qv4di = 7306,
CODE_FOR_avx512vl_cvtmask2qv2di = 7307,
CODE_FOR_vec_unpacks_hi_v4sf = 7308,
CODE_FOR_vec_unpacks_hi_v8sf = 7309,
CODE_FOR_vec_unpacks_hi_v16sf = 7310,
CODE_FOR_vec_unpacks_lo_v4sf = 7311,
CODE_FOR_vec_unpacks_lo_v8sf = 7312,
CODE_FOR_vec_unpacks_float_hi_v32hi = 7313,
CODE_FOR_vec_unpacks_float_hi_v16hi = 7314,
CODE_FOR_vec_unpacks_float_hi_v8hi = 7315,
CODE_FOR_vec_unpacks_float_lo_v32hi = 7316,
CODE_FOR_vec_unpacks_float_lo_v16hi = 7317,
CODE_FOR_vec_unpacks_float_lo_v8hi = 7318,
CODE_FOR_vec_unpacku_float_hi_v32hi = 7319,
CODE_FOR_vec_unpacku_float_hi_v16hi = 7320,
CODE_FOR_vec_unpacku_float_hi_v8hi = 7321,
CODE_FOR_vec_unpacku_float_lo_v32hi = 7322,
CODE_FOR_vec_unpacku_float_lo_v16hi = 7323,
CODE_FOR_vec_unpacku_float_lo_v8hi = 7324,
CODE_FOR_vec_unpacks_float_hi_v4si = 7325,
CODE_FOR_vec_unpacks_float_lo_v4si = 7326,
CODE_FOR_vec_unpacks_float_hi_v8si = 7327,
CODE_FOR_vec_unpacks_float_lo_v8si = 7328,
CODE_FOR_vec_unpacks_float_hi_v16si = 7329,
CODE_FOR_vec_unpacks_float_lo_v16si = 7330,
CODE_FOR_vec_unpacku_float_hi_v4si = 7331,
CODE_FOR_vec_unpacku_float_lo_v4si = 7332,
CODE_FOR_vec_unpacku_float_hi_v8si = 7333,
CODE_FOR_vec_unpacku_float_hi_v16si = 7334,
CODE_FOR_vec_unpacku_float_lo_v8si = 7335,
CODE_FOR_vec_unpacku_float_lo_v16si = 7336,
CODE_FOR_vec_pack_trunc_v8df = 7337,
CODE_FOR_vec_pack_trunc_v4df = 7338,
CODE_FOR_vec_pack_trunc_v2df = 7339,
CODE_FOR_vec_pack_sfix_trunc_v8df = 7340,
CODE_FOR_vec_pack_sfix_trunc_v4df = 7341,
CODE_FOR_vec_pack_sfix_trunc_v2df = 7342,
CODE_FOR_vec_pack_ufix_trunc_v8df = 7343,
CODE_FOR_vec_pack_ufix_trunc_v4df = 7344,
CODE_FOR_vec_pack_ufix_trunc_v2df = 7345,
CODE_FOR_avx512f_vec_pack_sfix_v8df = 7346,
CODE_FOR_vec_pack_sfix_v4df = 7347,
CODE_FOR_vec_pack_sfix_v2df = 7348,
CODE_FOR_sse_movhlps_exp = 7349,
CODE_FOR_sse_movlhps_exp = 7350,
CODE_FOR_vec_interleave_highv8sf = 7351,
CODE_FOR_vec_interleave_lowv8sf = 7352,
CODE_FOR_avx_shufps256 = 7353,
CODE_FOR_avx_shufps256_mask = 7354,
CODE_FOR_sse_shufps = 7355,
CODE_FOR_sse_shufps_mask = 7356,
CODE_FOR_sse_loadhps_exp = 7357,
CODE_FOR_sse_loadlps_exp = 7358,
CODE_FOR_vec_setv64qi = 7359,
CODE_FOR_vec_setv32qi = 7360,
CODE_FOR_vec_setv16qi = 7361,
CODE_FOR_vec_setv32hi = 7362,
CODE_FOR_vec_setv16hi = 7363,
CODE_FOR_vec_setv8hi = 7364,
CODE_FOR_vec_setv16si = 7365,
CODE_FOR_vec_setv8si = 7366,
CODE_FOR_vec_setv4si = 7367,
CODE_FOR_vec_setv8di = 7368,
CODE_FOR_vec_setv4di = 7369,
CODE_FOR_vec_setv2di = 7370,
CODE_FOR_vec_setv16sf = 7371,
CODE_FOR_vec_setv8sf = 7372,
CODE_FOR_vec_setv4sf = 7373,
CODE_FOR_vec_setv8df = 7374,
CODE_FOR_vec_setv4df = 7375,
CODE_FOR_vec_setv2df = 7376,
CODE_FOR_avx512dq_vextractf64x2_mask = 7377,
CODE_FOR_avx512dq_vextracti64x2_mask = 7378,
CODE_FOR_avx512f_vextractf32x4_mask = 7379,
CODE_FOR_avx512f_vextracti32x4_mask = 7380,
CODE_FOR_avx512dq_vextractf32x8_mask = 7381,
CODE_FOR_avx512dq_vextracti32x8_mask = 7382,
CODE_FOR_avx512f_vextractf64x4_mask = 7383,
CODE_FOR_avx512f_vextracti64x4_mask = 7384,
CODE_FOR_avx512vl_vextractf128v8si = 7385,
CODE_FOR_avx512vl_vextractf128v8sf = 7386,
CODE_FOR_avx512vl_vextractf128v4di = 7387,
CODE_FOR_avx512vl_vextractf128v4df = 7388,
CODE_FOR_avx_vextractf128v32qi = 7389,
CODE_FOR_avx_vextractf128v16hi = 7390,
CODE_FOR_avx_vextractf128v8si = 7391,
CODE_FOR_avx_vextractf128v4di = 7392,
CODE_FOR_avx_vextractf128v8sf = 7393,
CODE_FOR_avx_vextractf128v4df = 7394,
CODE_FOR_vec_extractv64qiqi = 7395,
CODE_FOR_vec_extractv32qiqi = 7396,
CODE_FOR_vec_extractv16qiqi = 7397,
CODE_FOR_vec_extractv32hihi = 7398,
CODE_FOR_vec_extractv16hihi = 7399,
CODE_FOR_vec_extractv8hihi = 7400,
CODE_FOR_vec_extractv16sisi = 7401,
CODE_FOR_vec_extractv8sisi = 7402,
CODE_FOR_vec_extractv4sisi = 7403,
CODE_FOR_vec_extractv8didi = 7404,
CODE_FOR_vec_extractv4didi = 7405,
CODE_FOR_vec_extractv2didi = 7406,
CODE_FOR_vec_extractv16sfsf = 7407,
CODE_FOR_vec_extractv8sfsf = 7408,
CODE_FOR_vec_extractv4sfsf = 7409,
CODE_FOR_vec_extractv8dfdf = 7410,
CODE_FOR_vec_extractv4dfdf = 7411,
CODE_FOR_vec_extractv2dfdf = 7412,
CODE_FOR_vec_extractv4titi = 7413,
CODE_FOR_vec_extractv2titi = 7414,
CODE_FOR_vec_extractv32qiv16qi = 7415,
CODE_FOR_vec_extractv16hiv8hi = 7416,
CODE_FOR_vec_extractv8siv4si = 7417,
CODE_FOR_vec_extractv4div2di = 7418,
CODE_FOR_vec_extractv8sfv4sf = 7419,
CODE_FOR_vec_extractv4dfv2df = 7420,
CODE_FOR_vec_extractv64qiv32qi = 7421,
CODE_FOR_vec_extractv32hiv16hi = 7422,
CODE_FOR_vec_extractv16siv8si = 7423,
CODE_FOR_vec_extractv8div4di = 7424,
CODE_FOR_vec_extractv16sfv8sf = 7425,
CODE_FOR_vec_extractv8dfv4df = 7426,
CODE_FOR_vec_interleave_highv4df = 7427,
CODE_FOR_vec_interleave_highv2df = 7428,
CODE_FOR_avx512f_movddup512 = 7429,
CODE_FOR_avx512f_movddup512_mask = 7430,
CODE_FOR_avx512f_unpcklpd512 = 7431,
CODE_FOR_avx512f_unpcklpd512_mask = 7432,
CODE_FOR_avx_movddup256 = 7433,
CODE_FOR_avx_movddup256_mask = 7434,
CODE_FOR_avx_unpcklpd256 = 7435,
CODE_FOR_avx_unpcklpd256_mask = 7436,
CODE_FOR_vec_interleave_lowv4df = 7437,
CODE_FOR_vec_interleave_lowv2df = 7438,
CODE_FOR_avx512f_vternlogv16si_maskz = 7439,
CODE_FOR_avx512vl_vternlogv8si_maskz = 7440,
CODE_FOR_avx512vl_vternlogv4si_maskz = 7441,
CODE_FOR_avx512f_vternlogv8di_maskz = 7442,
CODE_FOR_avx512vl_vternlogv4di_maskz = 7443,
CODE_FOR_avx512vl_vternlogv2di_maskz = 7444,
CODE_FOR_avx512f_shufps512_mask = 7445,
CODE_FOR_avx512f_fixupimmv16sf_maskz = 7446,
CODE_FOR_avx512f_fixupimmv16sf_maskz_round = 7447,
CODE_FOR_avx512vl_fixupimmv8sf_maskz = 7448,
CODE_FOR_avx512vl_fixupimmv8sf_maskz_round = 7449,
CODE_FOR_avx512vl_fixupimmv4sf_maskz = 7450,
CODE_FOR_avx512vl_fixupimmv4sf_maskz_round = 7451,
CODE_FOR_avx512f_fixupimmv8df_maskz = 7452,
CODE_FOR_avx512f_fixupimmv8df_maskz_round = 7453,
CODE_FOR_avx512vl_fixupimmv4df_maskz = 7454,
CODE_FOR_avx512vl_fixupimmv4df_maskz_round = 7455,
CODE_FOR_avx512vl_fixupimmv2df_maskz = 7456,
CODE_FOR_avx512vl_fixupimmv2df_maskz_round = 7457,
CODE_FOR_avx512f_sfixupimmv4sf_maskz = 7458,
CODE_FOR_avx512f_sfixupimmv4sf_maskz_round = 7459,
CODE_FOR_avx512f_sfixupimmv2df_maskz = 7460,
CODE_FOR_avx512f_sfixupimmv2df_maskz_round = 7461,
CODE_FOR_avx512f_shufpd512_mask = 7462,
CODE_FOR_avx_shufpd256 = 7463,
CODE_FOR_avx_shufpd256_mask = 7464,
CODE_FOR_sse2_shufpd = 7465,
CODE_FOR_sse2_shufpd_mask = 7466,
CODE_FOR_sse2_loadhpd_exp = 7467,
CODE_FOR_sse2_loadlpd_exp = 7468,
CODE_FOR_truncv16siv16qi2 = 7469,
CODE_FOR_truncv16siv16hi2 = 7470,
CODE_FOR_truncv8div8si2 = 7471,
CODE_FOR_truncv8div8hi2 = 7472,
CODE_FOR_avx512f_ss_truncatev16siv16qi2_mask_store = 7473,
CODE_FOR_avx512f_truncatev16siv16qi2_mask_store = 7474,
CODE_FOR_avx512f_us_truncatev16siv16qi2_mask_store = 7475,
CODE_FOR_avx512f_ss_truncatev16siv16hi2_mask_store = 7476,
CODE_FOR_avx512f_truncatev16siv16hi2_mask_store = 7477,
CODE_FOR_avx512f_us_truncatev16siv16hi2_mask_store = 7478,
CODE_FOR_avx512f_ss_truncatev8div8si2_mask_store = 7479,
CODE_FOR_avx512f_truncatev8div8si2_mask_store = 7480,
CODE_FOR_avx512f_us_truncatev8div8si2_mask_store = 7481,
CODE_FOR_avx512f_ss_truncatev8div8hi2_mask_store = 7482,
CODE_FOR_avx512f_truncatev8div8hi2_mask_store = 7483,
CODE_FOR_avx512f_us_truncatev8div8hi2_mask_store = 7484,
CODE_FOR_truncv32hiv32qi2 = 7485,
CODE_FOR_avx512bw_ss_truncatev32hiv32qi2_mask_store = 7486,
CODE_FOR_avx512bw_truncatev32hiv32qi2_mask_store = 7487,
CODE_FOR_avx512bw_us_truncatev32hiv32qi2_mask_store = 7488,
CODE_FOR_truncv4div4si2 = 7489,
CODE_FOR_truncv8siv8hi2 = 7490,
CODE_FOR_truncv16hiv16qi2 = 7491,
CODE_FOR_avx512vl_ss_truncatev4div4si2_mask_store = 7492,
CODE_FOR_avx512vl_truncatev4div4si2_mask_store = 7493,
CODE_FOR_avx512vl_us_truncatev4div4si2_mask_store = 7494,
CODE_FOR_avx512vl_ss_truncatev8siv8hi2_mask_store = 7495,
CODE_FOR_avx512vl_truncatev8siv8hi2_mask_store = 7496,
CODE_FOR_avx512vl_us_truncatev8siv8hi2_mask_store = 7497,
CODE_FOR_avx512vl_ss_truncatev16hiv16qi2_mask_store = 7498,
CODE_FOR_avx512vl_truncatev16hiv16qi2_mask_store = 7499,
CODE_FOR_avx512vl_us_truncatev16hiv16qi2_mask_store = 7500,
CODE_FOR_truncv4div4qi2 = 7501,
CODE_FOR_truncv2div2qi2 = 7502,
CODE_FOR_truncv8siv8qi2 = 7503,
CODE_FOR_truncv4siv4qi2 = 7504,
CODE_FOR_truncv8hiv8qi2 = 7505,
CODE_FOR_truncv4diV4HI2 = 7506,
CODE_FOR_truncv2diV2HI2 = 7507,
CODE_FOR_truncv4siV4HI2 = 7508,
CODE_FOR_truncv2div2si2 = 7509,
CODE_FOR_truncv8div8qi2 = 7510,
CODE_FOR_negv64qi2 = 7511,
CODE_FOR_negv32qi2 = 7512,
CODE_FOR_negv16qi2 = 7513,
CODE_FOR_negv32hi2 = 7514,
CODE_FOR_negv16hi2 = 7515,
CODE_FOR_negv8hi2 = 7516,
CODE_FOR_negv16si2 = 7517,
CODE_FOR_negv8si2 = 7518,
CODE_FOR_negv4si2 = 7519,
CODE_FOR_negv8di2 = 7520,
CODE_FOR_negv4di2 = 7521,
CODE_FOR_negv2di2 = 7522,
CODE_FOR_addv64qi3 = 7523,
CODE_FOR_subv64qi3 = 7524,
CODE_FOR_addv32qi3 = 7525,
CODE_FOR_subv32qi3 = 7526,
CODE_FOR_addv16qi3 = 7527,
CODE_FOR_subv16qi3 = 7528,
CODE_FOR_addv32hi3 = 7529,
CODE_FOR_subv32hi3 = 7530,
CODE_FOR_addv16hi3 = 7531,
CODE_FOR_subv16hi3 = 7532,
CODE_FOR_addv8hi3 = 7533,
CODE_FOR_subv8hi3 = 7534,
CODE_FOR_addv16si3 = 7535,
CODE_FOR_subv16si3 = 7536,
CODE_FOR_addv8si3 = 7537,
CODE_FOR_subv8si3 = 7538,
CODE_FOR_addv4si3 = 7539,
CODE_FOR_subv4si3 = 7540,
CODE_FOR_addv8di3 = 7541,
CODE_FOR_subv8di3 = 7542,
CODE_FOR_addv4di3 = 7543,
CODE_FOR_subv4di3 = 7544,
CODE_FOR_addv2di3 = 7545,
CODE_FOR_subv2di3 = 7546,
CODE_FOR_addv16si3_mask = 7547,
CODE_FOR_subv16si3_mask = 7548,
CODE_FOR_addv8si3_mask = 7549,
CODE_FOR_subv8si3_mask = 7550,
CODE_FOR_addv4si3_mask = 7551,
CODE_FOR_subv4si3_mask = 7552,
CODE_FOR_addv8di3_mask = 7553,
CODE_FOR_subv8di3_mask = 7554,
CODE_FOR_addv4di3_mask = 7555,
CODE_FOR_subv4di3_mask = 7556,
CODE_FOR_addv2di3_mask = 7557,
CODE_FOR_subv2di3_mask = 7558,
CODE_FOR_addv64qi3_mask = 7559,
CODE_FOR_subv64qi3_mask = 7560,
CODE_FOR_addv16qi3_mask = 7561,
CODE_FOR_subv16qi3_mask = 7562,
CODE_FOR_addv32qi3_mask = 7563,
CODE_FOR_subv32qi3_mask = 7564,
CODE_FOR_addv32hi3_mask = 7565,
CODE_FOR_subv32hi3_mask = 7566,
CODE_FOR_addv16hi3_mask = 7567,
CODE_FOR_subv16hi3_mask = 7568,
CODE_FOR_addv8hi3_mask = 7569,
CODE_FOR_subv8hi3_mask = 7570,
CODE_FOR_avx512bw_ssaddv64qi3 = 7571,
CODE_FOR_avx512bw_ssaddv64qi3_mask = 7572,
CODE_FOR_avx512bw_usaddv64qi3 = 7573,
CODE_FOR_avx512bw_usaddv64qi3_mask = 7574,
CODE_FOR_avx512bw_sssubv64qi3 = 7575,
CODE_FOR_avx512bw_sssubv64qi3_mask = 7576,
CODE_FOR_avx512bw_ussubv64qi3 = 7577,
CODE_FOR_avx512bw_ussubv64qi3_mask = 7578,
CODE_FOR_avx2_ssaddv32qi3 = 7579,
CODE_FOR_avx2_ssaddv32qi3_mask = 7580,
CODE_FOR_avx2_usaddv32qi3 = 7581,
CODE_FOR_avx2_usaddv32qi3_mask = 7582,
CODE_FOR_avx2_sssubv32qi3 = 7583,
CODE_FOR_avx2_sssubv32qi3_mask = 7584,
CODE_FOR_avx2_ussubv32qi3 = 7585,
CODE_FOR_avx2_ussubv32qi3_mask = 7586,
CODE_FOR_sse2_ssaddv16qi3 = 7587,
CODE_FOR_sse2_ssaddv16qi3_mask = 7588,
CODE_FOR_sse2_usaddv16qi3 = 7589,
CODE_FOR_sse2_usaddv16qi3_mask = 7590,
CODE_FOR_sse2_sssubv16qi3 = 7591,
CODE_FOR_sse2_sssubv16qi3_mask = 7592,
CODE_FOR_sse2_ussubv16qi3 = 7593,
CODE_FOR_sse2_ussubv16qi3_mask = 7594,
CODE_FOR_avx512bw_ssaddv32hi3 = 7595,
CODE_FOR_avx512bw_ssaddv32hi3_mask = 7596,
CODE_FOR_avx512bw_usaddv32hi3 = 7597,
CODE_FOR_avx512bw_usaddv32hi3_mask = 7598,
CODE_FOR_avx512bw_sssubv32hi3 = 7599,
CODE_FOR_avx512bw_sssubv32hi3_mask = 7600,
CODE_FOR_avx512bw_ussubv32hi3 = 7601,
CODE_FOR_avx512bw_ussubv32hi3_mask = 7602,
CODE_FOR_avx2_ssaddv16hi3 = 7603,
CODE_FOR_avx2_ssaddv16hi3_mask = 7604,
CODE_FOR_avx2_usaddv16hi3 = 7605,
CODE_FOR_avx2_usaddv16hi3_mask = 7606,
CODE_FOR_avx2_sssubv16hi3 = 7607,
CODE_FOR_avx2_sssubv16hi3_mask = 7608,
CODE_FOR_avx2_ussubv16hi3 = 7609,
CODE_FOR_avx2_ussubv16hi3_mask = 7610,
CODE_FOR_sse2_ssaddv8hi3 = 7611,
CODE_FOR_sse2_ssaddv8hi3_mask = 7612,
CODE_FOR_sse2_usaddv8hi3 = 7613,
CODE_FOR_sse2_usaddv8hi3_mask = 7614,
CODE_FOR_sse2_sssubv8hi3 = 7615,
CODE_FOR_sse2_sssubv8hi3_mask = 7616,
CODE_FOR_sse2_ussubv8hi3 = 7617,
CODE_FOR_sse2_ussubv8hi3_mask = 7618,
CODE_FOR_mulv8qi3 = 7619,
CODE_FOR_mulv64qi3 = 7620,
CODE_FOR_mulv32qi3 = 7621,
CODE_FOR_mulv16qi3 = 7622,
CODE_FOR_mulv32hi3 = 7623,
CODE_FOR_mulv32hi3_mask = 7624,
CODE_FOR_mulv16hi3 = 7625,
CODE_FOR_mulv16hi3_mask = 7626,
CODE_FOR_mulv8hi3 = 7627,
CODE_FOR_mulv8hi3_mask = 7628,
CODE_FOR_smulv32hi3_highpart = 7629,
CODE_FOR_smulv32hi3_highpart_mask = 7630,
CODE_FOR_umulv32hi3_highpart = 7631,
CODE_FOR_umulv32hi3_highpart_mask = 7632,
CODE_FOR_smulv16hi3_highpart = 7633,
CODE_FOR_smulv16hi3_highpart_mask = 7634,
CODE_FOR_umulv16hi3_highpart = 7635,
CODE_FOR_umulv16hi3_highpart_mask = 7636,
CODE_FOR_smulv8hi3_highpart = 7637,
CODE_FOR_smulv8hi3_highpart_mask = 7638,
CODE_FOR_umulv8hi3_highpart = 7639,
CODE_FOR_umulv8hi3_highpart_mask = 7640,
CODE_FOR_vec_widen_umult_even_v16si = 7641,
CODE_FOR_vec_widen_umult_even_v16si_mask = 7642,
CODE_FOR_vec_widen_umult_even_v8si = 7643,
CODE_FOR_vec_widen_umult_even_v8si_mask = 7644,
CODE_FOR_vec_widen_umult_even_v4si = 7645,
CODE_FOR_vec_widen_umult_even_v4si_mask = 7646,
CODE_FOR_vec_widen_smult_even_v16si = 7647,
CODE_FOR_vec_widen_smult_even_v16si_mask = 7648,
CODE_FOR_vec_widen_smult_even_v8si = 7649,
CODE_FOR_vec_widen_smult_even_v8si_mask = 7650,
CODE_FOR_sse4_1_mulv2siv2di3 = 7651,
CODE_FOR_sse4_1_mulv2siv2di3_mask = 7652,
CODE_FOR_avx2_pmaddwd = 7653,
CODE_FOR_sse2_pmaddwd = 7654,
CODE_FOR_mulv16si3 = 7655,
CODE_FOR_mulv16si3_mask = 7656,
CODE_FOR_mulv8si3 = 7657,
CODE_FOR_mulv8si3_mask = 7658,
CODE_FOR_mulv4si3 = 7659,
CODE_FOR_mulv4si3_mask = 7660,
CODE_FOR_mulv8di3 = 7661,
CODE_FOR_mulv4di3 = 7662,
CODE_FOR_mulv2di3 = 7663,
CODE_FOR_vec_widen_smult_hi_v32qi = 7664,
CODE_FOR_vec_widen_umult_hi_v32qi = 7665,
CODE_FOR_vec_widen_smult_hi_v16qi = 7666,
CODE_FOR_vec_widen_umult_hi_v16qi = 7667,
CODE_FOR_vec_widen_smult_hi_v16hi = 7668,
CODE_FOR_vec_widen_umult_hi_v16hi = 7669,
CODE_FOR_vec_widen_smult_hi_v8hi = 7670,
CODE_FOR_vec_widen_umult_hi_v8hi = 7671,
CODE_FOR_vec_widen_smult_hi_v8si = 7672,
CODE_FOR_vec_widen_umult_hi_v8si = 7673,
CODE_FOR_vec_widen_smult_hi_v4si = 7674,
CODE_FOR_vec_widen_umult_hi_v4si = 7675,
CODE_FOR_vec_widen_smult_lo_v32qi = 7676,
CODE_FOR_vec_widen_umult_lo_v32qi = 7677,
CODE_FOR_vec_widen_smult_lo_v16qi = 7678,
CODE_FOR_vec_widen_umult_lo_v16qi = 7679,
CODE_FOR_vec_widen_smult_lo_v16hi = 7680,
CODE_FOR_vec_widen_umult_lo_v16hi = 7681,
CODE_FOR_vec_widen_smult_lo_v8hi = 7682,
CODE_FOR_vec_widen_umult_lo_v8hi = 7683,
CODE_FOR_vec_widen_smult_lo_v8si = 7684,
CODE_FOR_vec_widen_umult_lo_v8si = 7685,
CODE_FOR_vec_widen_smult_lo_v4si = 7686,
CODE_FOR_vec_widen_umult_lo_v4si = 7687,
CODE_FOR_vec_widen_smult_even_v4si = 7688,
CODE_FOR_vec_widen_smult_odd_v16si = 7689,
CODE_FOR_vec_widen_umult_odd_v16si = 7690,
CODE_FOR_vec_widen_smult_odd_v8si = 7691,
CODE_FOR_vec_widen_umult_odd_v8si = 7692,
CODE_FOR_vec_widen_smult_odd_v4si = 7693,
CODE_FOR_vec_widen_umult_odd_v4si = 7694,
CODE_FOR_sdot_prodv32hi = 7695,
CODE_FOR_sdot_prodv16hi = 7696,
CODE_FOR_sdot_prodv8hi = 7697,
CODE_FOR_sdot_prodv4si = 7698,
CODE_FOR_uavgv64qi3_ceil = 7699,
CODE_FOR_uavgv32qi3_ceil = 7700,
CODE_FOR_uavgv16qi3_ceil = 7701,
CODE_FOR_uavgv32hi3_ceil = 7702,
CODE_FOR_uavgv16hi3_ceil = 7703,
CODE_FOR_uavgv8hi3_ceil = 7704,
CODE_FOR_usadv16qi = 7705,
CODE_FOR_usadv32qi = 7706,
CODE_FOR_usadv64qi = 7707,
CODE_FOR_vec_shl_v16qi = 7708,
CODE_FOR_vec_shl_v8hi = 7709,
CODE_FOR_vec_shl_v4si = 7710,
CODE_FOR_vec_shl_v2di = 7711,
CODE_FOR_vec_shl_v4sf = 7712,
CODE_FOR_vec_shl_v2df = 7713,
CODE_FOR_vec_shr_v16qi = 7714,
CODE_FOR_vec_shr_v8hi = 7715,
CODE_FOR_vec_shr_v4si = 7716,
CODE_FOR_vec_shr_v2di = 7717,
CODE_FOR_vec_shr_v4sf = 7718,
CODE_FOR_vec_shr_v2df = 7719,
CODE_FOR_smaxv32qi3 = 7720,
CODE_FOR_sminv32qi3 = 7721,
CODE_FOR_umaxv32qi3 = 7722,
CODE_FOR_uminv32qi3 = 7723,
CODE_FOR_smaxv16hi3 = 7724,
CODE_FOR_sminv16hi3 = 7725,
CODE_FOR_umaxv16hi3 = 7726,
CODE_FOR_uminv16hi3 = 7727,
CODE_FOR_smaxv8si3 = 7728,
CODE_FOR_sminv8si3 = 7729,
CODE_FOR_umaxv8si3 = 7730,
CODE_FOR_uminv8si3 = 7731,
CODE_FOR_smaxv64qi3 = 7732,
CODE_FOR_sminv64qi3 = 7733,
CODE_FOR_umaxv64qi3 = 7734,
CODE_FOR_uminv64qi3 = 7735,
CODE_FOR_smaxv32hi3 = 7736,
CODE_FOR_sminv32hi3 = 7737,
CODE_FOR_umaxv32hi3 = 7738,
CODE_FOR_uminv32hi3 = 7739,
CODE_FOR_smaxv16si3 = 7740,
CODE_FOR_sminv16si3 = 7741,
CODE_FOR_umaxv16si3 = 7742,
CODE_FOR_uminv16si3 = 7743,
CODE_FOR_smaxv16si3_mask = 7744,
CODE_FOR_sminv16si3_mask = 7745,
CODE_FOR_umaxv16si3_mask = 7746,
CODE_FOR_uminv16si3_mask = 7747,
CODE_FOR_smaxv8si3_mask = 7748,
CODE_FOR_sminv8si3_mask = 7749,
CODE_FOR_umaxv8si3_mask = 7750,
CODE_FOR_uminv8si3_mask = 7751,
CODE_FOR_smaxv4si3_mask = 7752,
CODE_FOR_sminv4si3_mask = 7753,
CODE_FOR_umaxv4si3_mask = 7754,
CODE_FOR_uminv4si3_mask = 7755,
CODE_FOR_smaxv8di3_mask = 7756,
CODE_FOR_sminv8di3_mask = 7757,
CODE_FOR_umaxv8di3_mask = 7758,
CODE_FOR_uminv8di3_mask = 7759,
CODE_FOR_smaxv4di3_mask = 7760,
CODE_FOR_sminv4di3_mask = 7761,
CODE_FOR_umaxv4di3_mask = 7762,
CODE_FOR_uminv4di3_mask = 7763,
CODE_FOR_smaxv2di3_mask = 7764,
CODE_FOR_sminv2di3_mask = 7765,
CODE_FOR_umaxv2di3_mask = 7766,
CODE_FOR_uminv2di3_mask = 7767,
CODE_FOR_smaxv8di3 = 7768,
CODE_FOR_sminv8di3 = 7769,
CODE_FOR_umaxv8di3 = 7770,
CODE_FOR_uminv8di3 = 7771,
CODE_FOR_smaxv4di3 = 7772,
CODE_FOR_sminv4di3 = 7773,
CODE_FOR_umaxv4di3 = 7774,
CODE_FOR_uminv4di3 = 7775,
CODE_FOR_smaxv2di3 = 7776,
CODE_FOR_sminv2di3 = 7777,
CODE_FOR_umaxv2di3 = 7778,
CODE_FOR_uminv2di3 = 7779,
CODE_FOR_smaxv16qi3 = 7780,
CODE_FOR_sminv16qi3 = 7781,
CODE_FOR_smaxv8hi3 = 7782,
CODE_FOR_sminv8hi3 = 7783,
CODE_FOR_smaxv4si3 = 7784,
CODE_FOR_sminv4si3 = 7785,
CODE_FOR_umaxv16qi3 = 7786,
CODE_FOR_uminv16qi3 = 7787,
CODE_FOR_umaxv8hi3 = 7788,
CODE_FOR_uminv8hi3 = 7789,
CODE_FOR_umaxv4si3 = 7790,
CODE_FOR_uminv4si3 = 7791,
CODE_FOR_avx2_eqv32qi3 = 7792,
CODE_FOR_avx2_eqv16hi3 = 7793,
CODE_FOR_avx2_eqv8si3 = 7794,
CODE_FOR_avx2_eqv4di3 = 7795,
CODE_FOR_avx512bw_eqv64qi3 = 7796,
CODE_FOR_avx512bw_eqv64qi3_mask = 7797,
CODE_FOR_avx512vl_eqv16qi3 = 7798,
CODE_FOR_avx512vl_eqv16qi3_mask = 7799,
CODE_FOR_avx512vl_eqv32qi3 = 7800,
CODE_FOR_avx512vl_eqv32qi3_mask = 7801,
CODE_FOR_avx512bw_eqv32hi3 = 7802,
CODE_FOR_avx512bw_eqv32hi3_mask = 7803,
CODE_FOR_avx512vl_eqv16hi3 = 7804,
CODE_FOR_avx512vl_eqv16hi3_mask = 7805,
CODE_FOR_avx512vl_eqv8hi3 = 7806,
CODE_FOR_avx512vl_eqv8hi3_mask = 7807,
CODE_FOR_avx512f_eqv16si3 = 7808,
CODE_FOR_avx512f_eqv16si3_mask = 7809,
CODE_FOR_avx512vl_eqv8si3 = 7810,
CODE_FOR_avx512vl_eqv8si3_mask = 7811,
CODE_FOR_avx512vl_eqv4si3 = 7812,
CODE_FOR_avx512vl_eqv4si3_mask = 7813,
CODE_FOR_avx512f_eqv8di3 = 7814,
CODE_FOR_avx512f_eqv8di3_mask = 7815,
CODE_FOR_avx512vl_eqv4di3 = 7816,
CODE_FOR_avx512vl_eqv4di3_mask = 7817,
CODE_FOR_avx512vl_eqv2di3 = 7818,
CODE_FOR_avx512vl_eqv2di3_mask = 7819,
CODE_FOR_sse2_eqv16qi3 = 7820,
CODE_FOR_sse2_eqv8hi3 = 7821,
CODE_FOR_sse2_eqv4si3 = 7822,
CODE_FOR_sse4_1_eqv2di3 = 7823,
CODE_FOR_vcondv64qiv16si = 7824,
CODE_FOR_vcondv32hiv16si = 7825,
CODE_FOR_vcondv16siv16si = 7826,
CODE_FOR_vcondv8div16si = 7827,
CODE_FOR_vcondv16sfv16si = 7828,
CODE_FOR_vcondv8dfv16si = 7829,
CODE_FOR_vcondv64qiv8di = 7830,
CODE_FOR_vcondv32hiv8di = 7831,
CODE_FOR_vcondv16siv8di = 7832,
CODE_FOR_vcondv8div8di = 7833,
CODE_FOR_vcondv16sfv8di = 7834,
CODE_FOR_vcondv8dfv8di = 7835,
CODE_FOR_vcondv64qiv32hi = 7836,
CODE_FOR_vcondv32hiv32hi = 7837,
CODE_FOR_vcondv16siv32hi = 7838,
CODE_FOR_vcondv8div32hi = 7839,
CODE_FOR_vcondv16sfv32hi = 7840,
CODE_FOR_vcondv8dfv32hi = 7841,
CODE_FOR_vcondv64qiv64qi = 7842,
CODE_FOR_vcondv32hiv64qi = 7843,
CODE_FOR_vcondv16siv64qi = 7844,
CODE_FOR_vcondv8div64qi = 7845,
CODE_FOR_vcondv16sfv64qi = 7846,
CODE_FOR_vcondv8dfv64qi = 7847,
CODE_FOR_vcondv32qiv32qi = 7848,
CODE_FOR_vcondv16hiv32qi = 7849,
CODE_FOR_vcondv8siv32qi = 7850,
CODE_FOR_vcondv4div32qi = 7851,
CODE_FOR_vcondv8sfv32qi = 7852,
CODE_FOR_vcondv4dfv32qi = 7853,
CODE_FOR_vcondv32qiv16hi = 7854,
CODE_FOR_vcondv16hiv16hi = 7855,
CODE_FOR_vcondv8siv16hi = 7856,
CODE_FOR_vcondv4div16hi = 7857,
CODE_FOR_vcondv8sfv16hi = 7858,
CODE_FOR_vcondv4dfv16hi = 7859,
CODE_FOR_vcondv32qiv8si = 7860,
CODE_FOR_vcondv16hiv8si = 7861,
CODE_FOR_vcondv8siv8si = 7862,
CODE_FOR_vcondv4div8si = 7863,
CODE_FOR_vcondv8sfv8si = 7864,
CODE_FOR_vcondv4dfv8si = 7865,
CODE_FOR_vcondv32qiv4di = 7866,
CODE_FOR_vcondv16hiv4di = 7867,
CODE_FOR_vcondv8siv4di = 7868,
CODE_FOR_vcondv4div4di = 7869,
CODE_FOR_vcondv8sfv4di = 7870,
CODE_FOR_vcondv4dfv4di = 7871,
CODE_FOR_vcondv16qiv16qi = 7872,
CODE_FOR_vcondv8hiv16qi = 7873,
CODE_FOR_vcondv4siv16qi = 7874,
CODE_FOR_vcondv2div16qi = 7875,
CODE_FOR_vcondv4sfv16qi = 7876,
CODE_FOR_vcondv2dfv16qi = 7877,
CODE_FOR_vcondv16qiv8hi = 7878,
CODE_FOR_vcondv8hiv8hi = 7879,
CODE_FOR_vcondv4siv8hi = 7880,
CODE_FOR_vcondv2div8hi = 7881,
CODE_FOR_vcondv4sfv8hi = 7882,
CODE_FOR_vcondv2dfv8hi = 7883,
CODE_FOR_vcondv16qiv4si = 7884,
CODE_FOR_vcondv8hiv4si = 7885,
CODE_FOR_vcondv4siv4si = 7886,
CODE_FOR_vcondv2div4si = 7887,
CODE_FOR_vcondv4sfv4si = 7888,
CODE_FOR_vcondv2dfv4si = 7889,
CODE_FOR_vcondv2div2di = 7890,
CODE_FOR_vcondv2dfv2di = 7891,
CODE_FOR_vconduv64qiv16si = 7892,
CODE_FOR_vconduv32hiv16si = 7893,
CODE_FOR_vconduv16siv16si = 7894,
CODE_FOR_vconduv8div16si = 7895,
CODE_FOR_vconduv16sfv16si = 7896,
CODE_FOR_vconduv8dfv16si = 7897,
CODE_FOR_vconduv64qiv8di = 7898,
CODE_FOR_vconduv32hiv8di = 7899,
CODE_FOR_vconduv16siv8di = 7900,
CODE_FOR_vconduv8div8di = 7901,
CODE_FOR_vconduv16sfv8di = 7902,
CODE_FOR_vconduv8dfv8di = 7903,
CODE_FOR_vconduv64qiv32hi = 7904,
CODE_FOR_vconduv32hiv32hi = 7905,
CODE_FOR_vconduv16siv32hi = 7906,
CODE_FOR_vconduv8div32hi = 7907,
CODE_FOR_vconduv16sfv32hi = 7908,
CODE_FOR_vconduv8dfv32hi = 7909,
CODE_FOR_vconduv64qiv64qi = 7910,
CODE_FOR_vconduv32hiv64qi = 7911,
CODE_FOR_vconduv16siv64qi = 7912,
CODE_FOR_vconduv8div64qi = 7913,
CODE_FOR_vconduv16sfv64qi = 7914,
CODE_FOR_vconduv8dfv64qi = 7915,
CODE_FOR_vconduv32qiv32qi = 7916,
CODE_FOR_vconduv16hiv32qi = 7917,
CODE_FOR_vconduv8siv32qi = 7918,
CODE_FOR_vconduv4div32qi = 7919,
CODE_FOR_vconduv8sfv32qi = 7920,
CODE_FOR_vconduv4dfv32qi = 7921,
CODE_FOR_vconduv32qiv16hi = 7922,
CODE_FOR_vconduv16hiv16hi = 7923,
CODE_FOR_vconduv8siv16hi = 7924,
CODE_FOR_vconduv4div16hi = 7925,
CODE_FOR_vconduv8sfv16hi = 7926,
CODE_FOR_vconduv4dfv16hi = 7927,
CODE_FOR_vconduv32qiv8si = 7928,
CODE_FOR_vconduv16hiv8si = 7929,
CODE_FOR_vconduv8siv8si = 7930,
CODE_FOR_vconduv4div8si = 7931,
CODE_FOR_vconduv8sfv8si = 7932,
CODE_FOR_vconduv4dfv8si = 7933,
CODE_FOR_vconduv32qiv4di = 7934,
CODE_FOR_vconduv16hiv4di = 7935,
CODE_FOR_vconduv8siv4di = 7936,
CODE_FOR_vconduv4div4di = 7937,
CODE_FOR_vconduv8sfv4di = 7938,
CODE_FOR_vconduv4dfv4di = 7939,
CODE_FOR_vconduv16qiv16qi = 7940,
CODE_FOR_vconduv8hiv16qi = 7941,
CODE_FOR_vconduv4siv16qi = 7942,
CODE_FOR_vconduv2div16qi = 7943,
CODE_FOR_vconduv4sfv16qi = 7944,
CODE_FOR_vconduv2dfv16qi = 7945,
CODE_FOR_vconduv16qiv8hi = 7946,
CODE_FOR_vconduv8hiv8hi = 7947,
CODE_FOR_vconduv4siv8hi = 7948,
CODE_FOR_vconduv2div8hi = 7949,
CODE_FOR_vconduv4sfv8hi = 7950,
CODE_FOR_vconduv2dfv8hi = 7951,
CODE_FOR_vconduv16qiv4si = 7952,
CODE_FOR_vconduv8hiv4si = 7953,
CODE_FOR_vconduv4siv4si = 7954,
CODE_FOR_vconduv2div4si = 7955,
CODE_FOR_vconduv4sfv4si = 7956,
CODE_FOR_vconduv2dfv4si = 7957,
CODE_FOR_vconduv2div2di = 7958,
CODE_FOR_vconduv2dfv2di = 7959,
CODE_FOR_vcondeqv2div2di = 7960,
CODE_FOR_vcondeqv2dfv2di = 7961,
CODE_FOR_vec_permv16qi = 7962,
CODE_FOR_vec_permv8hi = 7963,
CODE_FOR_vec_permv4si = 7964,
CODE_FOR_vec_permv2di = 7965,
CODE_FOR_vec_permv4sf = 7966,
CODE_FOR_vec_permv2df = 7967,
CODE_FOR_vec_permv32qi = 7968,
CODE_FOR_vec_permv16hi = 7969,
CODE_FOR_vec_permv8si = 7970,
CODE_FOR_vec_permv4di = 7971,
CODE_FOR_vec_permv8sf = 7972,
CODE_FOR_vec_permv4df = 7973,
CODE_FOR_vec_permv16sf = 7974,
CODE_FOR_vec_permv8df = 7975,
CODE_FOR_vec_permv16si = 7976,
CODE_FOR_vec_permv8di = 7977,
CODE_FOR_vec_permv32hi = 7978,
CODE_FOR_vec_permv64qi = 7979,
CODE_FOR_one_cmplv16si2 = 7980,
CODE_FOR_one_cmplv8di2 = 7981,
CODE_FOR_one_cmplv64qi2 = 7982,
CODE_FOR_one_cmplv32qi2 = 7983,
CODE_FOR_one_cmplv16qi2 = 7984,
CODE_FOR_one_cmplv32hi2 = 7985,
CODE_FOR_one_cmplv16hi2 = 7986,
CODE_FOR_one_cmplv8hi2 = 7987,
CODE_FOR_one_cmplv8si2 = 7988,
CODE_FOR_one_cmplv4si2 = 7989,
CODE_FOR_one_cmplv4di2 = 7990,
CODE_FOR_one_cmplv2di2 = 7991,
CODE_FOR_avx512bw_andnotv64qi3 = 7992,
CODE_FOR_avx2_andnotv32qi3 = 7993,
CODE_FOR_sse2_andnotv16qi3 = 7994,
CODE_FOR_avx512bw_andnotv32hi3 = 7995,
CODE_FOR_avx2_andnotv16hi3 = 7996,
CODE_FOR_sse2_andnotv8hi3 = 7997,
CODE_FOR_avx512f_andnotv16si3 = 7998,
CODE_FOR_avx2_andnotv8si3 = 7999,
CODE_FOR_sse2_andnotv4si3 = 8000,
CODE_FOR_avx512f_andnotv8di3 = 8001,
CODE_FOR_avx2_andnotv4di3 = 8002,
CODE_FOR_sse2_andnotv2di3 = 8003,
CODE_FOR_avx512f_andnotv16si3_mask = 8004,
CODE_FOR_avx2_andnotv8si3_mask = 8005,
CODE_FOR_sse2_andnotv4si3_mask = 8006,
CODE_FOR_avx512f_andnotv8di3_mask = 8007,
CODE_FOR_avx2_andnotv4di3_mask = 8008,
CODE_FOR_sse2_andnotv2di3_mask = 8009,
CODE_FOR_avx512bw_andnotv64qi3_mask = 8010,
CODE_FOR_sse2_andnotv16qi3_mask = 8011,
CODE_FOR_avx2_andnotv32qi3_mask = 8012,
CODE_FOR_avx512bw_andnotv32hi3_mask = 8013,
CODE_FOR_avx2_andnotv16hi3_mask = 8014,
CODE_FOR_sse2_andnotv8hi3_mask = 8015,
CODE_FOR_andv16si3 = 8016,
CODE_FOR_iorv16si3 = 8017,
CODE_FOR_xorv16si3 = 8018,
CODE_FOR_andv8di3 = 8019,
CODE_FOR_iorv8di3 = 8020,
CODE_FOR_xorv8di3 = 8021,
CODE_FOR_andv64qi3 = 8022,
CODE_FOR_iorv64qi3 = 8023,
CODE_FOR_xorv64qi3 = 8024,
CODE_FOR_andv32qi3 = 8025,
CODE_FOR_iorv32qi3 = 8026,
CODE_FOR_xorv32qi3 = 8027,
CODE_FOR_andv16qi3 = 8028,
CODE_FOR_iorv16qi3 = 8029,
CODE_FOR_xorv16qi3 = 8030,
CODE_FOR_andv32hi3 = 8031,
CODE_FOR_iorv32hi3 = 8032,
CODE_FOR_xorv32hi3 = 8033,
CODE_FOR_andv16hi3 = 8034,
CODE_FOR_iorv16hi3 = 8035,
CODE_FOR_xorv16hi3 = 8036,
CODE_FOR_andv8hi3 = 8037,
CODE_FOR_iorv8hi3 = 8038,
CODE_FOR_xorv8hi3 = 8039,
CODE_FOR_andv8si3 = 8040,
CODE_FOR_iorv8si3 = 8041,
CODE_FOR_xorv8si3 = 8042,
CODE_FOR_andv4si3 = 8043,
CODE_FOR_iorv4si3 = 8044,
CODE_FOR_xorv4si3 = 8045,
CODE_FOR_andv4di3 = 8046,
CODE_FOR_iorv4di3 = 8047,
CODE_FOR_xorv4di3 = 8048,
CODE_FOR_andv2di3 = 8049,
CODE_FOR_iorv2di3 = 8050,
CODE_FOR_xorv2di3 = 8051,
CODE_FOR_vec_pack_trunc_v32hi = 8052,
CODE_FOR_vec_pack_trunc_v16hi = 8053,
CODE_FOR_vec_pack_trunc_v8hi = 8054,
CODE_FOR_vec_pack_trunc_v16si = 8055,
CODE_FOR_vec_pack_trunc_v8si = 8056,
CODE_FOR_vec_pack_trunc_v4si = 8057,
CODE_FOR_vec_pack_trunc_v8di = 8058,
CODE_FOR_vec_pack_trunc_v4di = 8059,
CODE_FOR_vec_pack_trunc_v2di = 8060,
CODE_FOR_vec_pack_trunc_qi = 8061,
CODE_FOR_vec_pack_trunc_hi = 8062,
CODE_FOR_vec_pack_trunc_si = 8063,
CODE_FOR_vec_pack_sbool_trunc_qi = 8064,
CODE_FOR_vec_interleave_highv32qi = 8065,
CODE_FOR_vec_interleave_highv16hi = 8066,
CODE_FOR_vec_interleave_highv8si = 8067,
CODE_FOR_vec_interleave_highv4di = 8068,
CODE_FOR_vec_interleave_lowv32qi = 8069,
CODE_FOR_vec_interleave_lowv16hi = 8070,
CODE_FOR_vec_interleave_lowv8si = 8071,
CODE_FOR_vec_interleave_lowv4di = 8072,
CODE_FOR_avx512dq_vinsertf64x2_mask = 8073,
CODE_FOR_avx512dq_vinserti64x2_mask = 8074,
CODE_FOR_avx512f_vinsertf32x4_mask = 8075,
CODE_FOR_avx512f_vinserti32x4_mask = 8076,
CODE_FOR_avx512dq_vinsertf32x8_mask = 8077,
CODE_FOR_avx512dq_vinserti32x8_mask = 8078,
CODE_FOR_avx512f_vinsertf64x4_mask = 8079,
CODE_FOR_avx512f_vinserti64x4_mask = 8080,
CODE_FOR_avx512dq_shuf_i64x2_mask = 8081,
CODE_FOR_avx512dq_shuf_f64x2_mask = 8082,
CODE_FOR_avx512f_shuf_f64x2_mask = 8083,
CODE_FOR_avx512f_shuf_i64x2_mask = 8084,
CODE_FOR_avx512vl_shuf_i32x4_mask = 8085,
CODE_FOR_avx512vl_shuf_f32x4_mask = 8086,
CODE_FOR_avx512f_shuf_f32x4_mask = 8087,
CODE_FOR_avx512f_shuf_i32x4_mask = 8088,
CODE_FOR_avx512f_pshufdv3_mask = 8089,
CODE_FOR_avx512vl_pshufdv3_mask = 8090,
CODE_FOR_avx2_pshufdv3 = 8091,
CODE_FOR_avx512vl_pshufd_mask = 8092,
CODE_FOR_sse2_pshufd = 8093,
CODE_FOR_avx512vl_pshuflwv3_mask = 8094,
CODE_FOR_avx2_pshuflwv3 = 8095,
CODE_FOR_avx512vl_pshuflw_mask = 8096,
CODE_FOR_sse2_pshuflw = 8097,
CODE_FOR_avx2_pshufhwv3 = 8098,
CODE_FOR_avx512vl_pshufhwv3_mask = 8099,
CODE_FOR_avx512vl_pshufhw_mask = 8100,
CODE_FOR_sse2_pshufhw = 8101,
CODE_FOR_sse2_loadd = 8102,
CODE_FOR_vec_unpacks_lo_v64qi = 8103,
CODE_FOR_vec_unpacks_lo_v32qi = 8104,
CODE_FOR_vec_unpacks_lo_v16qi = 8105,
CODE_FOR_vec_unpacks_lo_v32hi = 8106,
CODE_FOR_vec_unpacks_lo_v16hi = 8107,
CODE_FOR_vec_unpacks_lo_v8hi = 8108,
CODE_FOR_vec_unpacks_lo_v16si = 8109,
CODE_FOR_vec_unpacks_lo_v8si = 8110,
CODE_FOR_vec_unpacks_lo_v4si = 8111,
CODE_FOR_vec_unpacks_hi_v64qi = 8112,
CODE_FOR_vec_unpacks_hi_v32qi = 8113,
CODE_FOR_vec_unpacks_hi_v16qi = 8114,
CODE_FOR_vec_unpacks_hi_v32hi = 8115,
CODE_FOR_vec_unpacks_hi_v16hi = 8116,
CODE_FOR_vec_unpacks_hi_v8hi = 8117,
CODE_FOR_vec_unpacks_hi_v16si = 8118,
CODE_FOR_vec_unpacks_hi_v8si = 8119,
CODE_FOR_vec_unpacks_hi_v4si = 8120,
CODE_FOR_vec_unpacku_lo_v64qi = 8121,
CODE_FOR_vec_unpacku_lo_v32qi = 8122,
CODE_FOR_vec_unpacku_lo_v16qi = 8123,
CODE_FOR_vec_unpacku_lo_v32hi = 8124,
CODE_FOR_vec_unpacku_lo_v16hi = 8125,
CODE_FOR_vec_unpacku_lo_v8hi = 8126,
CODE_FOR_vec_unpacku_lo_v16si = 8127,
CODE_FOR_vec_unpacku_lo_v8si = 8128,
CODE_FOR_vec_unpacku_lo_v4si = 8129,
CODE_FOR_vec_unpacks_sbool_lo_qi = 8130,
CODE_FOR_vec_unpacks_lo_hi = 8131,
CODE_FOR_vec_unpacks_lo_si = 8132,
CODE_FOR_vec_unpacks_lo_di = 8133,
CODE_FOR_vec_unpacku_hi_v64qi = 8134,
CODE_FOR_vec_unpacku_hi_v32qi = 8135,
CODE_FOR_vec_unpacku_hi_v16qi = 8136,
CODE_FOR_vec_unpacku_hi_v32hi = 8137,
CODE_FOR_vec_unpacku_hi_v16hi = 8138,
CODE_FOR_vec_unpacku_hi_v8hi = 8139,
CODE_FOR_vec_unpacku_hi_v16si = 8140,
CODE_FOR_vec_unpacku_hi_v8si = 8141,
CODE_FOR_vec_unpacku_hi_v4si = 8142,
CODE_FOR_vec_unpacks_sbool_hi_qi = 8143,
CODE_FOR_vec_unpacks_hi_hi = 8144,
CODE_FOR_vec_unpacks_hi_si = 8145,
CODE_FOR_vec_unpacks_hi_di = 8146,
CODE_FOR_avx512bw_uavgv64qi3 = 8147,
CODE_FOR_avx512bw_uavgv64qi3_mask = 8148,
CODE_FOR_avx2_uavgv32qi3 = 8149,
CODE_FOR_avx2_uavgv32qi3_mask = 8150,
CODE_FOR_sse2_uavgv16qi3 = 8151,
CODE_FOR_sse2_uavgv16qi3_mask = 8152,
CODE_FOR_avx512bw_uavgv32hi3 = 8153,
CODE_FOR_avx512bw_uavgv32hi3_mask = 8154,
CODE_FOR_avx2_uavgv16hi3 = 8155,
CODE_FOR_avx2_uavgv16hi3_mask = 8156,
CODE_FOR_sse2_uavgv8hi3 = 8157,
CODE_FOR_sse2_uavgv8hi3_mask = 8158,
CODE_FOR_sse2_maskmovdqu = 8159,
CODE_FOR_ssse3_pmulhrswv8hi3_mask = 8160,
CODE_FOR_avx2_pmulhrswv16hi3_mask = 8161,
CODE_FOR_ssse3_pmulhrswv8hi3 = 8162,
CODE_FOR_avx2_pmulhrswv16hi3 = 8163,
CODE_FOR_smulhrsv32hi3 = 8164,
CODE_FOR_smulhrsv16hi3 = 8165,
CODE_FOR_smulhrsv8hi3 = 8166,
CODE_FOR_smulhrsv4hi3 = 8167,
CODE_FOR_ssse3_pmulhrswv4hi3 = 8168,
CODE_FOR_absv64qi2 = 8169,
CODE_FOR_absv32qi2 = 8170,
CODE_FOR_absv16qi2 = 8171,
CODE_FOR_absv32hi2 = 8172,
CODE_FOR_absv16hi2 = 8173,
CODE_FOR_absv8hi2 = 8174,
CODE_FOR_absv16si2 = 8175,
CODE_FOR_absv8si2 = 8176,
CODE_FOR_absv4si2 = 8177,
CODE_FOR_absv8di2 = 8178,
CODE_FOR_absv4di2 = 8179,
CODE_FOR_absv2di2 = 8180,
CODE_FOR_avx2_pblendw = 8181,
CODE_FOR_sign_extendv16qiv16hi2 = 8182,
CODE_FOR_zero_extendv16qiv16hi2 = 8183,
CODE_FOR_sign_extendv32qiv32hi2 = 8184,
CODE_FOR_zero_extendv32qiv32hi2 = 8185,
CODE_FOR_sign_extendv8qiv8hi2 = 8186,
CODE_FOR_zero_extendv8qiv8hi2 = 8187,
CODE_FOR_sign_extendv16qiv16si2 = 8188,
CODE_FOR_zero_extendv16qiv16si2 = 8189,
CODE_FOR_sign_extendv8qiv8si2 = 8190,
CODE_FOR_zero_extendv8qiv8si2 = 8191,
CODE_FOR_sign_extendv4qiv4si2 = 8192,
CODE_FOR_zero_extendv4qiv4si2 = 8193,
CODE_FOR_sign_extendv16hiv16si2 = 8194,
CODE_FOR_zero_extendv16hiv16si2 = 8195,
CODE_FOR_sign_extendv8hiv8si2 = 8196,
CODE_FOR_zero_extendv8hiv8si2 = 8197,
CODE_FOR_sign_extendv4hiv4si2 = 8198,
CODE_FOR_zero_extendv4hiv4si2 = 8199,
CODE_FOR_sign_extendv8qiv8di2 = 8200,
CODE_FOR_zero_extendv8qiv8di2 = 8201,
CODE_FOR_sign_extendv4qiv4di2 = 8202,
CODE_FOR_zero_extendv4qiv4di2 = 8203,
CODE_FOR_sign_extendv2qiv2di2 = 8204,
CODE_FOR_zero_extendv2qiv2di2 = 8205,
CODE_FOR_sign_extendv8hiv8di2 = 8206,
CODE_FOR_zero_extendv8hiv8di2 = 8207,
CODE_FOR_sign_extendv4hiv4di2 = 8208,
CODE_FOR_zero_extendv4hiv4di2 = 8209,
CODE_FOR_sign_extendv2hiv2di2 = 8210,
CODE_FOR_zero_extendv2hiv2di2 = 8211,
CODE_FOR_sign_extendv8siv8di2 = 8212,
CODE_FOR_zero_extendv8siv8di2 = 8213,
CODE_FOR_sign_extendv4siv4di2 = 8214,
CODE_FOR_zero_extendv4siv4di2 = 8215,
CODE_FOR_sign_extendv2siv2di2 = 8216,
CODE_FOR_zero_extendv2siv2di2 = 8217,
CODE_FOR_nearbyintv16sf2 = 8218,
CODE_FOR_nearbyintv8sf2 = 8219,
CODE_FOR_nearbyintv4sf2 = 8220,
CODE_FOR_nearbyintv8df2 = 8221,
CODE_FOR_nearbyintv4df2 = 8222,
CODE_FOR_nearbyintv2df2 = 8223,
CODE_FOR_rintv16sf2 = 8224,
CODE_FOR_rintv8sf2 = 8225,
CODE_FOR_rintv4sf2 = 8226,
CODE_FOR_rintv8df2 = 8227,
CODE_FOR_rintv4df2 = 8228,
CODE_FOR_rintv2df2 = 8229,
CODE_FOR_avx_roundps_sfix256 = 8230,
CODE_FOR_sse4_1_roundps_sfix = 8231,
CODE_FOR_avx512f_roundps512 = 8232,
CODE_FOR_avx512f_roundpd512 = 8233,
CODE_FOR_avx512f_roundps512_sfix = 8234,
CODE_FOR_avx512f_roundpd_vec_pack_sfix512 = 8235,
CODE_FOR_avx_roundpd_vec_pack_sfix256 = 8236,
CODE_FOR_sse4_1_roundpd_vec_pack_sfix = 8237,
CODE_FOR_roundv16sf2 = 8238,
CODE_FOR_roundv8sf2 = 8239,
CODE_FOR_roundv4sf2 = 8240,
CODE_FOR_roundv8df2 = 8241,
CODE_FOR_roundv4df2 = 8242,
CODE_FOR_roundv2df2 = 8243,
CODE_FOR_roundv16sf2_sfix = 8244,
CODE_FOR_roundv8sf2_sfix = 8245,
CODE_FOR_roundv4sf2_sfix = 8246,
CODE_FOR_roundv8df2_vec_pack_sfix = 8247,
CODE_FOR_roundv4df2_vec_pack_sfix = 8248,
CODE_FOR_roundv2df2_vec_pack_sfix = 8249,
CODE_FOR_avx512pf_gatherpfv16sisf = 8250,
CODE_FOR_avx512pf_gatherpfv8disf = 8251,
CODE_FOR_avx512pf_gatherpfv8sidf = 8252,
CODE_FOR_avx512pf_gatherpfv8didf = 8253,
CODE_FOR_avx512pf_scatterpfv16sisf = 8254,
CODE_FOR_avx512pf_scatterpfv8disf = 8255,
CODE_FOR_avx512pf_scatterpfv8sidf = 8256,
CODE_FOR_avx512pf_scatterpfv8didf = 8257,
CODE_FOR_rotlv16qi3 = 8258,
CODE_FOR_rotlv8hi3 = 8259,
CODE_FOR_rotlv4si3 = 8260,
CODE_FOR_rotlv2di3 = 8261,
CODE_FOR_rotrv16qi3 = 8262,
CODE_FOR_rotrv8hi3 = 8263,
CODE_FOR_rotrv4si3 = 8264,
CODE_FOR_rotrv2di3 = 8265,
CODE_FOR_vrotrv16qi3 = 8266,
CODE_FOR_vrotrv8hi3 = 8267,
CODE_FOR_vrotrv4si3 = 8268,
CODE_FOR_vrotrv2di3 = 8269,
CODE_FOR_vrotlv16qi3 = 8270,
CODE_FOR_vrotlv8hi3 = 8271,
CODE_FOR_vrotlv4si3 = 8272,
CODE_FOR_vrotlv2di3 = 8273,
CODE_FOR_vlshrv16qi3 = 8274,
CODE_FOR_vlshrv8hi3 = 8275,
CODE_FOR_vlshrv4si3 = 8276,
CODE_FOR_vlshrv2di3 = 8277,
CODE_FOR_vlshrv16si3 = 8278,
CODE_FOR_vlshrv8di3 = 8279,
CODE_FOR_vlshrv8si3 = 8280,
CODE_FOR_vlshrv4di3 = 8281,
CODE_FOR_vashrv8hi3 = 8282,
CODE_FOR_vashrv8hi3_mask = 8283,
CODE_FOR_vashrv16qi3 = 8284,
CODE_FOR_vashrv2di3 = 8285,
CODE_FOR_vashrv2di3_mask = 8286,
CODE_FOR_vashrv4si3 = 8287,
CODE_FOR_vashrv16si3 = 8288,
CODE_FOR_vashrv8si3 = 8289,
CODE_FOR_vashlv16qi3 = 8290,
CODE_FOR_vashlv8hi3 = 8291,
CODE_FOR_vashlv4si3 = 8292,
CODE_FOR_vashlv2di3 = 8293,
CODE_FOR_vashlv16si3 = 8294,
CODE_FOR_vashlv8di3 = 8295,
CODE_FOR_vashlv8si3 = 8296,
CODE_FOR_vashlv4di3 = 8297,
CODE_FOR_ashlv64qi3 = 8298,
CODE_FOR_lshrv64qi3 = 8299,
CODE_FOR_ashrv64qi3 = 8300,
CODE_FOR_ashlv32qi3 = 8301,
CODE_FOR_lshrv32qi3 = 8302,
CODE_FOR_ashrv32qi3 = 8303,
CODE_FOR_ashlv16qi3 = 8304,
CODE_FOR_lshrv16qi3 = 8305,
CODE_FOR_ashrv16qi3 = 8306,
CODE_FOR_ashrv2di3 = 8307,
CODE_FOR_xop_vmfrczv4sf2 = 8308,
CODE_FOR_xop_vmfrczv2df2 = 8309,
CODE_FOR_avx_vzeroall = 8310,
CODE_FOR_avx_vzeroupper = 8311,
CODE_FOR_avx512f_vpermilv8df = 8312,
CODE_FOR_avx512f_vpermilv8df_mask = 8313,
CODE_FOR_avx_vpermilv4df = 8314,
CODE_FOR_avx_vpermilv4df_mask = 8315,
CODE_FOR_avx_vpermilv2df = 8316,
CODE_FOR_avx_vpermilv2df_mask = 8317,
CODE_FOR_avx512f_vpermilv16sf = 8318,
CODE_FOR_avx512f_vpermilv16sf_mask = 8319,
CODE_FOR_avx_vpermilv8sf = 8320,
CODE_FOR_avx_vpermilv8sf_mask = 8321,
CODE_FOR_avx_vpermilv4sf = 8322,
CODE_FOR_avx_vpermilv4sf_mask = 8323,
CODE_FOR_avx2_permv4di = 8324,
CODE_FOR_avx2_permv4df = 8325,
CODE_FOR_avx512vl_permv4di_mask = 8326,
CODE_FOR_avx512vl_permv4df_mask = 8327,
CODE_FOR_avx512f_permv8df = 8328,
CODE_FOR_avx512f_permv8di = 8329,
CODE_FOR_avx512f_permv8df_mask = 8330,
CODE_FOR_avx512f_permv8di_mask = 8331,
CODE_FOR_avx512f_vpermi2varv16si3_mask = 8332,
CODE_FOR_avx512f_vpermi2varv16sf3_mask = 8333,
CODE_FOR_avx512f_vpermi2varv8di3_mask = 8334,
CODE_FOR_avx512f_vpermi2varv8df3_mask = 8335,
CODE_FOR_avx512vl_vpermi2varv8si3_mask = 8336,
CODE_FOR_avx512vl_vpermi2varv8sf3_mask = 8337,
CODE_FOR_avx512vl_vpermi2varv4di3_mask = 8338,
CODE_FOR_avx512vl_vpermi2varv4df3_mask = 8339,
CODE_FOR_avx512vl_vpermi2varv4si3_mask = 8340,
CODE_FOR_avx512vl_vpermi2varv4sf3_mask = 8341,
CODE_FOR_avx512vl_vpermi2varv2di3_mask = 8342,
CODE_FOR_avx512vl_vpermi2varv2df3_mask = 8343,
CODE_FOR_avx512bw_vpermi2varv32hi3_mask = 8344,
CODE_FOR_avx512vl_vpermi2varv16hi3_mask = 8345,
CODE_FOR_avx512vl_vpermi2varv8hi3_mask = 8346,
CODE_FOR_avx512bw_vpermi2varv64qi3_mask = 8347,
CODE_FOR_avx512vl_vpermi2varv32qi3_mask = 8348,
CODE_FOR_avx512vl_vpermi2varv16qi3_mask = 8349,
CODE_FOR_avx512f_vpermt2varv16si3_maskz = 8350,
CODE_FOR_avx512f_vpermt2varv16sf3_maskz = 8351,
CODE_FOR_avx512f_vpermt2varv8di3_maskz = 8352,
CODE_FOR_avx512f_vpermt2varv8df3_maskz = 8353,
CODE_FOR_avx512vl_vpermt2varv8si3_maskz = 8354,
CODE_FOR_avx512vl_vpermt2varv8sf3_maskz = 8355,
CODE_FOR_avx512vl_vpermt2varv4di3_maskz = 8356,
CODE_FOR_avx512vl_vpermt2varv4df3_maskz = 8357,
CODE_FOR_avx512vl_vpermt2varv4si3_maskz = 8358,
CODE_FOR_avx512vl_vpermt2varv4sf3_maskz = 8359,
CODE_FOR_avx512vl_vpermt2varv2di3_maskz = 8360,
CODE_FOR_avx512vl_vpermt2varv2df3_maskz = 8361,
CODE_FOR_avx512bw_vpermt2varv32hi3_maskz = 8362,
CODE_FOR_avx512vl_vpermt2varv16hi3_maskz = 8363,
CODE_FOR_avx512vl_vpermt2varv8hi3_maskz = 8364,
CODE_FOR_avx512bw_vpermt2varv64qi3_maskz = 8365,
CODE_FOR_avx512vl_vpermt2varv32qi3_maskz = 8366,
CODE_FOR_avx512vl_vpermt2varv16qi3_maskz = 8367,
CODE_FOR_avx_vperm2f128v8si3 = 8368,
CODE_FOR_avx_vperm2f128v8sf3 = 8369,
CODE_FOR_avx_vperm2f128v4df3 = 8370,
CODE_FOR_avx512vl_vinsertv8si = 8371,
CODE_FOR_avx512vl_vinsertv8sf = 8372,
CODE_FOR_avx512vl_vinsertv4di = 8373,
CODE_FOR_avx512vl_vinsertv4df = 8374,
CODE_FOR_avx_vinsertf128v32qi = 8375,
CODE_FOR_avx_vinsertf128v16hi = 8376,
CODE_FOR_avx_vinsertf128v8si = 8377,
CODE_FOR_avx_vinsertf128v4di = 8378,
CODE_FOR_avx_vinsertf128v8sf = 8379,
CODE_FOR_avx_vinsertf128v4df = 8380,
CODE_FOR_maskloadv4sfv4si = 8381,
CODE_FOR_maskloadv2dfv2di = 8382,
CODE_FOR_maskloadv8sfv8si = 8383,
CODE_FOR_maskloadv4dfv4di = 8384,
CODE_FOR_maskloadv4siv4si = 8385,
CODE_FOR_maskloadv2div2di = 8386,
CODE_FOR_maskloadv8siv8si = 8387,
CODE_FOR_maskloadv4div4di = 8388,
CODE_FOR_maskloadv16sihi = 8389,
CODE_FOR_maskloadv8siqi = 8390,
CODE_FOR_maskloadv4siqi = 8391,
CODE_FOR_maskloadv8diqi = 8392,
CODE_FOR_maskloadv4diqi = 8393,
CODE_FOR_maskloadv2diqi = 8394,
CODE_FOR_maskloadv16sfhi = 8395,
CODE_FOR_maskloadv8sfqi = 8396,
CODE_FOR_maskloadv4sfqi = 8397,
CODE_FOR_maskloadv8dfqi = 8398,
CODE_FOR_maskloadv4dfqi = 8399,
CODE_FOR_maskloadv2dfqi = 8400,
CODE_FOR_maskloadv64qidi = 8401,
CODE_FOR_maskloadv16qihi = 8402,
CODE_FOR_maskloadv32qisi = 8403,
CODE_FOR_maskloadv32hisi = 8404,
CODE_FOR_maskloadv16hihi = 8405,
CODE_FOR_maskloadv8hiqi = 8406,
CODE_FOR_maskstorev4sfv4si = 8407,
CODE_FOR_maskstorev2dfv2di = 8408,
CODE_FOR_maskstorev8sfv8si = 8409,
CODE_FOR_maskstorev4dfv4di = 8410,
CODE_FOR_maskstorev4siv4si = 8411,
CODE_FOR_maskstorev2div2di = 8412,
CODE_FOR_maskstorev8siv8si = 8413,
CODE_FOR_maskstorev4div4di = 8414,
CODE_FOR_maskstorev16sihi = 8415,
CODE_FOR_maskstorev8siqi = 8416,
CODE_FOR_maskstorev4siqi = 8417,
CODE_FOR_maskstorev8diqi = 8418,
CODE_FOR_maskstorev4diqi = 8419,
CODE_FOR_maskstorev2diqi = 8420,
CODE_FOR_maskstorev16sfhi = 8421,
CODE_FOR_maskstorev8sfqi = 8422,
CODE_FOR_maskstorev4sfqi = 8423,
CODE_FOR_maskstorev8dfqi = 8424,
CODE_FOR_maskstorev4dfqi = 8425,
CODE_FOR_maskstorev2dfqi = 8426,
CODE_FOR_maskstorev64qidi = 8427,
CODE_FOR_maskstorev16qihi = 8428,
CODE_FOR_maskstorev32qisi = 8429,
CODE_FOR_maskstorev32hisi = 8430,
CODE_FOR_maskstorev16hihi = 8431,
CODE_FOR_maskstorev8hiqi = 8432,
CODE_FOR_cbranchv4si4 = 8433,
CODE_FOR_cbranchv2di4 = 8434,
CODE_FOR_cbranchv8si4 = 8435,
CODE_FOR_cbranchv4di4 = 8436,
CODE_FOR_vec_initv64qiqi = 8437,
CODE_FOR_vec_initv32qiqi = 8438,
CODE_FOR_vec_initv16qiqi = 8439,
CODE_FOR_vec_initv32hihi = 8440,
CODE_FOR_vec_initv16hihi = 8441,
CODE_FOR_vec_initv8hihi = 8442,
CODE_FOR_vec_initv16sisi = 8443,
CODE_FOR_vec_initv8sisi = 8444,
CODE_FOR_vec_initv4sisi = 8445,
CODE_FOR_vec_initv8didi = 8446,
CODE_FOR_vec_initv4didi = 8447,
CODE_FOR_vec_initv2didi = 8448,
CODE_FOR_vec_initv16sfsf = 8449,
CODE_FOR_vec_initv8sfsf = 8450,
CODE_FOR_vec_initv4sfsf = 8451,
CODE_FOR_vec_initv8dfdf = 8452,
CODE_FOR_vec_initv4dfdf = 8453,
CODE_FOR_vec_initv2dfdf = 8454,
CODE_FOR_vec_initv4titi = 8455,
CODE_FOR_vec_initv2titi = 8456,
CODE_FOR_vec_initv64qiv32qi = 8457,
CODE_FOR_vec_initv32qiv16qi = 8458,
CODE_FOR_vec_initv16qiv8qi = 8459,
CODE_FOR_vec_initv32hiv16hi = 8460,
CODE_FOR_vec_initv16hiv8hi = 8461,
CODE_FOR_vec_initv8hiv4hi = 8462,
CODE_FOR_vec_initv16siv8si = 8463,
CODE_FOR_vec_initv8siv4si = 8464,
CODE_FOR_vec_initv4siv2si = 8465,
CODE_FOR_vec_initv8div4di = 8466,
CODE_FOR_vec_initv4div2di = 8467,
CODE_FOR_vec_initv16sfv8sf = 8468,
CODE_FOR_vec_initv8sfv4sf = 8469,
CODE_FOR_vec_initv4sfv2sf = 8470,
CODE_FOR_vec_initv8dfv4df = 8471,
CODE_FOR_vec_initv4dfv2df = 8472,
CODE_FOR_vec_initv4tiv2ti = 8473,
CODE_FOR_vcvtps2ph_mask = 8474,
CODE_FOR_vcvtps2ph = 8475,
CODE_FOR_avx2_gathersiv2di = 8476,
CODE_FOR_avx2_gathersiv2df = 8477,
CODE_FOR_avx2_gathersiv4di = 8478,
CODE_FOR_avx2_gathersiv4df = 8479,
CODE_FOR_avx2_gathersiv4si = 8480,
CODE_FOR_avx2_gathersiv4sf = 8481,
CODE_FOR_avx2_gathersiv8si = 8482,
CODE_FOR_avx2_gathersiv8sf = 8483,
CODE_FOR_avx2_gatherdiv2di = 8484,
CODE_FOR_avx2_gatherdiv2df = 8485,
CODE_FOR_avx2_gatherdiv4di = 8486,
CODE_FOR_avx2_gatherdiv4df = 8487,
CODE_FOR_avx2_gatherdiv4si = 8488,
CODE_FOR_avx2_gatherdiv4sf = 8489,
CODE_FOR_avx2_gatherdiv8si = 8490,
CODE_FOR_avx2_gatherdiv8sf = 8491,
CODE_FOR_avx512f_gathersiv16si = 8492,
CODE_FOR_avx512f_gathersiv16sf = 8493,
CODE_FOR_avx512f_gathersiv8di = 8494,
CODE_FOR_avx512f_gathersiv8df = 8495,
CODE_FOR_avx512vl_gathersiv8si = 8496,
CODE_FOR_avx512vl_gathersiv8sf = 8497,
CODE_FOR_avx512vl_gathersiv4di = 8498,
CODE_FOR_avx512vl_gathersiv4df = 8499,
CODE_FOR_avx512vl_gathersiv4si = 8500,
CODE_FOR_avx512vl_gathersiv4sf = 8501,
CODE_FOR_avx512vl_gathersiv2di = 8502,
CODE_FOR_avx512vl_gathersiv2df = 8503,
CODE_FOR_avx512f_gatherdiv16si = 8504,
CODE_FOR_avx512f_gatherdiv16sf = 8505,
CODE_FOR_avx512f_gatherdiv8di = 8506,
CODE_FOR_avx512f_gatherdiv8df = 8507,
CODE_FOR_avx512vl_gatherdiv8si = 8508,
CODE_FOR_avx512vl_gatherdiv8sf = 8509,
CODE_FOR_avx512vl_gatherdiv4di = 8510,
CODE_FOR_avx512vl_gatherdiv4df = 8511,
CODE_FOR_avx512vl_gatherdiv4si = 8512,
CODE_FOR_avx512vl_gatherdiv4sf = 8513,
CODE_FOR_avx512vl_gatherdiv2di = 8514,
CODE_FOR_avx512vl_gatherdiv2df = 8515,
CODE_FOR_avx512f_scattersiv16si = 8516,
CODE_FOR_avx512f_scattersiv16sf = 8517,
CODE_FOR_avx512f_scattersiv8di = 8518,
CODE_FOR_avx512f_scattersiv8df = 8519,
CODE_FOR_avx512vl_scattersiv8si = 8520,
CODE_FOR_avx512vl_scattersiv8sf = 8521,
CODE_FOR_avx512vl_scattersiv4di = 8522,
CODE_FOR_avx512vl_scattersiv4df = 8523,
CODE_FOR_avx512vl_scattersiv4si = 8524,
CODE_FOR_avx512vl_scattersiv4sf = 8525,
CODE_FOR_avx512vl_scattersiv2di = 8526,
CODE_FOR_avx512vl_scattersiv2df = 8527,
CODE_FOR_avx512f_scatterdiv16si = 8528,
CODE_FOR_avx512f_scatterdiv16sf = 8529,
CODE_FOR_avx512f_scatterdiv8di = 8530,
CODE_FOR_avx512f_scatterdiv8df = 8531,
CODE_FOR_avx512vl_scatterdiv8si = 8532,
CODE_FOR_avx512vl_scatterdiv8sf = 8533,
CODE_FOR_avx512vl_scatterdiv4di = 8534,
CODE_FOR_avx512vl_scatterdiv4df = 8535,
CODE_FOR_avx512vl_scatterdiv4si = 8536,
CODE_FOR_avx512vl_scatterdiv4sf = 8537,
CODE_FOR_avx512vl_scatterdiv2di = 8538,
CODE_FOR_avx512vl_scatterdiv2df = 8539,
CODE_FOR_avx512f_expandv16si_maskz = 8540,
CODE_FOR_avx512f_expandv16sf_maskz = 8541,
CODE_FOR_avx512f_expandv8di_maskz = 8542,
CODE_FOR_avx512f_expandv8df_maskz = 8543,
CODE_FOR_avx512vl_expandv8si_maskz = 8544,
CODE_FOR_avx512vl_expandv8sf_maskz = 8545,
CODE_FOR_avx512vl_expandv4di_maskz = 8546,
CODE_FOR_avx512vl_expandv4df_maskz = 8547,
CODE_FOR_avx512vl_expandv4si_maskz = 8548,
CODE_FOR_avx512vl_expandv4sf_maskz = 8549,
CODE_FOR_avx512vl_expandv2di_maskz = 8550,
CODE_FOR_avx512vl_expandv2df_maskz = 8551,
CODE_FOR_expandv64qi_maskz = 8552,
CODE_FOR_expandv16qi_maskz = 8553,
CODE_FOR_expandv32qi_maskz = 8554,
CODE_FOR_expandv32hi_maskz = 8555,
CODE_FOR_expandv16hi_maskz = 8556,
CODE_FOR_expandv8hi_maskz = 8557,
CODE_FOR_vpamdd52huqv8di_maskz = 8558,
CODE_FOR_vpamdd52huqv4di_maskz = 8559,
CODE_FOR_vpamdd52huqv2di_maskz = 8560,
CODE_FOR_vpamdd52luqv8di_maskz = 8561,
CODE_FOR_vpamdd52luqv4di_maskz = 8562,
CODE_FOR_vpamdd52luqv2di_maskz = 8563,
CODE_FOR_movv64sf = 8564,
CODE_FOR_movv64si = 8565,
CODE_FOR_vpshrdv_v32hi_maskz = 8566,
CODE_FOR_vpshrdv_v16si_maskz = 8567,
CODE_FOR_vpshrdv_v8di_maskz = 8568,
CODE_FOR_vpshrdv_v16hi_maskz = 8569,
CODE_FOR_vpshrdv_v8si_maskz = 8570,
CODE_FOR_vpshrdv_v4di_maskz = 8571,
CODE_FOR_vpshrdv_v8hi_maskz = 8572,
CODE_FOR_vpshrdv_v4si_maskz = 8573,
CODE_FOR_vpshrdv_v2di_maskz = 8574,
CODE_FOR_vpshldv_v32hi_maskz = 8575,
CODE_FOR_vpshldv_v16si_maskz = 8576,
CODE_FOR_vpshldv_v8di_maskz = 8577,
CODE_FOR_vpshldv_v16hi_maskz = 8578,
CODE_FOR_vpshldv_v8si_maskz = 8579,
CODE_FOR_vpshldv_v4di_maskz = 8580,
CODE_FOR_vpshldv_v8hi_maskz = 8581,
CODE_FOR_vpshldv_v4si_maskz = 8582,
CODE_FOR_vpshldv_v2di_maskz = 8583,
CODE_FOR_vpdpbusd_v16si_maskz = 8584,
CODE_FOR_vpdpbusd_v8si_maskz = 8585,
CODE_FOR_vpdpbusd_v4si_maskz = 8586,
CODE_FOR_vpdpbusds_v16si_maskz = 8587,
CODE_FOR_vpdpbusds_v8si_maskz = 8588,
CODE_FOR_vpdpbusds_v4si_maskz = 8589,
CODE_FOR_vpdpwssd_v16si_maskz = 8590,
CODE_FOR_vpdpwssd_v8si_maskz = 8591,
CODE_FOR_vpdpwssd_v4si_maskz = 8592,
CODE_FOR_vpdpwssds_v16si_maskz = 8593,
CODE_FOR_vpdpwssds_v8si_maskz = 8594,
CODE_FOR_vpdpwssds_v4si_maskz = 8595,
CODE_FOR_avx512f_cvtne2ps2bf16_v32hi_maskz = 8596,
CODE_FOR_avx512f_cvtne2ps2bf16_v16hi_maskz = 8597,
CODE_FOR_avx512f_cvtne2ps2bf16_v8hi_maskz = 8598,
CODE_FOR_avx512f_cvtneps2bf16_v16sf_maskz = 8599,
CODE_FOR_avx512f_cvtneps2bf16_v8sf_maskz = 8600,
CODE_FOR_avx512f_cvtneps2bf16_v4sf_maskz = 8601,
CODE_FOR_avx512f_dpbf16ps_v16sf_maskz = 8602,
CODE_FOR_avx512f_dpbf16ps_v8sf_maskz = 8603,
CODE_FOR_avx512f_dpbf16ps_v4sf_maskz = 8604,
CODE_FOR_sse2_lfence = 8605,
CODE_FOR_sse_sfence = 8606,
CODE_FOR_sse2_mfence = 8607,
CODE_FOR_mem_thread_fence = 8608,
CODE_FOR_atomic_loadqi = 8609,
CODE_FOR_atomic_loadhi = 8610,
CODE_FOR_atomic_loadsi = 8611,
CODE_FOR_atomic_loaddi = 8612,
CODE_FOR_atomic_storeqi = 8613,
CODE_FOR_atomic_storehi = 8614,
CODE_FOR_atomic_storesi = 8615,
CODE_FOR_atomic_storedi = 8616,
CODE_FOR_atomic_compare_and_swapqi = 8617,
CODE_FOR_atomic_compare_and_swaphi = 8618,
CODE_FOR_atomic_compare_and_swapsi = 8619,
CODE_FOR_atomic_compare_and_swapdi = 8620,
CODE_FOR_atomic_compare_and_swapti = 8621,
CODE_FOR_atomic_bit_test_and_sethi = 8622,
CODE_FOR_atomic_bit_test_and_setsi = 8623,
CODE_FOR_atomic_bit_test_and_setdi = 8624,
CODE_FOR_atomic_bit_test_and_complementhi = 8625,
CODE_FOR_atomic_bit_test_and_complementsi = 8626,
CODE_FOR_atomic_bit_test_and_complementdi = 8627,
CODE_FOR_atomic_bit_test_and_resethi = 8628,
CODE_FOR_atomic_bit_test_and_resetsi = 8629,
CODE_FOR_atomic_bit_test_and_resetdi = 8630
};
const unsigned int NUM_INSN_CODES = 8631;
# 52 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h" 1
# 43 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h"
typedef unsigned long HARD_REG_ELT_TYPE;
# 56 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h"
struct HARD_REG_SET
{
HARD_REG_SET
operator~ () const
{
HARD_REG_SET res;
for (unsigned int i = 0; i < (sizeof (elts) / sizeof ((elts)[0])); ++i)
res.elts[i] = ~elts[i];
return res;
}
HARD_REG_SET
operator& (const HARD_REG_SET &other) const
{
HARD_REG_SET res;
for (unsigned int i = 0; i < (sizeof (elts) / sizeof ((elts)[0])); ++i)
res.elts[i] = elts[i] & other.elts[i];
return res;
}
HARD_REG_SET &
operator&= (const HARD_REG_SET &other)
{
for (unsigned int i = 0; i < (sizeof (elts) / sizeof ((elts)[0])); ++i)
elts[i] &= other.elts[i];
return *this;
}
HARD_REG_SET
operator| (const HARD_REG_SET &other) const
{
HARD_REG_SET res;
for (unsigned int i = 0; i < (sizeof (elts) / sizeof ((elts)[0])); ++i)
res.elts[i] = elts[i] | other.elts[i];
return res;
}
HARD_REG_SET &
operator|= (const HARD_REG_SET &other)
{
for (unsigned int i = 0; i < (sizeof (elts) / sizeof ((elts)[0])); ++i)
elts[i] |= other.elts[i];
return *this;
}
bool
operator== (const HARD_REG_SET &other) const
{
HARD_REG_ELT_TYPE bad = 0;
for (unsigned int i = 0; i < (sizeof (elts) / sizeof ((elts)[0])); ++i)
bad |= (elts[i] ^ other.elts[i]);
return bad == 0;
}
bool
operator!= (const HARD_REG_SET &other) const
{
return !operator== (other);
}
HARD_REG_ELT_TYPE elts[((76 + (8 * 8) - 1) / (8 * 8))];
};
typedef const HARD_REG_SET &const_hard_reg_set;
template<>
struct array_traits<HARD_REG_SET>
{
typedef HARD_REG_ELT_TYPE element_type;
static const bool has_constant_size = true;
static const size_t constant_size = ((76 + (8 * 8) - 1) / (8 * 8));
static const element_type *base (const HARD_REG_SET &x) { return x.elts; }
static size_t size (const HARD_REG_SET &) { return ((76 + (8 * 8) - 1) / (8 * 8)); }
};
struct hard_reg_set_container
{
HARD_REG_SET set;
};
# 196 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h"
inline void
SET_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
{
set.elts[bit / ((unsigned) (8 * 8))]
|= ((HARD_REG_ELT_TYPE) (1)) << (bit % ((unsigned) (8 * 8)));
}
inline void
CLEAR_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
{
set.elts[bit / ((unsigned) (8 * 8))]
&= ~(((HARD_REG_ELT_TYPE) (1)) << (bit % ((unsigned) (8 * 8))));
}
inline bool
TEST_HARD_REG_BIT (const_hard_reg_set set, unsigned int bit)
{
return (set.elts[bit / ((unsigned) (8 * 8))]
& (((HARD_REG_ELT_TYPE) (1)) << (bit % ((unsigned) (8 * 8)))));
}
inline void
CLEAR_HARD_REG_SET (HARD_REG_SET &set)
{
for (unsigned int i = 0; i < (sizeof (set.elts) / sizeof ((set.elts)[0])); ++i)
set.elts[i] = 0;
}
inline void
SET_HARD_REG_SET (HARD_REG_SET &set)
{
for (unsigned int i = 0; i < (sizeof (set.elts) / sizeof ((set.elts)[0])); ++i)
set.elts[i] = -1;
}
static inline bool
hard_reg_set_subset_p (const_hard_reg_set x, const_hard_reg_set y)
{
HARD_REG_ELT_TYPE bad = 0;
for (unsigned int i = 0; i < (sizeof (x.elts) / sizeof ((x.elts)[0])); ++i)
bad |= (x.elts[i] & ~y.elts[i]);
return bad == 0;
}
static inline bool
hard_reg_set_intersect_p (const_hard_reg_set x, const_hard_reg_set y)
{
HARD_REG_ELT_TYPE good = 0;
for (unsigned int i = 0; i < (sizeof (x.elts) / sizeof ((x.elts)[0])); ++i)
good |= (x.elts[i] & y.elts[i]);
return good != 0;
}
static inline bool
hard_reg_set_empty_p (const_hard_reg_set x)
{
HARD_REG_ELT_TYPE bad = 0;
for (unsigned int i = 0; i < (sizeof (x.elts) / sizeof ((x.elts)[0])); ++i)
bad |= x.elts[i];
return bad == 0;
}
struct hard_reg_set_iterator
{
const HARD_REG_ELT_TYPE *pelt;
unsigned short length;
unsigned short word_no;
HARD_REG_ELT_TYPE bits;
};
static inline void
hard_reg_set_iter_init (hard_reg_set_iterator *iter, const_hard_reg_set set,
unsigned min, unsigned *regno)
{
iter->pelt = set.elts;
iter->length = ((76 + (8 * 8) - 1) / (8 * 8));
iter->word_no = min / ((unsigned) (8 * 8));
if (iter->word_no < iter->length)
{
iter->bits = iter->pelt[iter->word_no];
iter->bits >>= min % ((unsigned) (8 * 8));
min += !iter->bits;
}
*regno = min;
}
static inline bool
hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno)
{
while (1)
{
if (iter->word_no >= iter->length)
return false;
if (iter->bits)
{
while (!(iter->bits & 1))
{
iter->bits >>= 1;
*regno += 1;
}
return (*regno < 76);
}
*regno = (*regno + ((unsigned) (8 * 8)) - 1);
*regno -= *regno % ((unsigned) (8 * 8));
while (++iter->word_no < iter->length)
{
iter->bits = iter->pelt[iter->word_no];
if (iter->bits)
break;
*regno += ((unsigned) (8 * 8));
}
}
}
static inline void
hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno)
{
iter->bits >>= 1;
*regno += 1;
}
# 360 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h"
extern char global_regs[76];
class simplifiable_subreg;
class subreg_shape;
struct simplifiable_subregs_hasher : nofree_ptr_hash <simplifiable_subreg>
{
typedef const subreg_shape *compare_type;
static inline hashval_t hash (const simplifiable_subreg *);
static inline bool equal (const simplifiable_subreg *, const subreg_shape *);
};
struct target_hard_regs {
void finalize ();
HARD_REG_SET x_accessible_reg_set;
HARD_REG_SET x_operand_reg_set;
char x_fixed_regs[76];
HARD_REG_SET x_fixed_reg_set;
char x_call_used_regs[76];
# 406 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h"
HARD_REG_SET x_savable_regs;
HARD_REG_SET x_fixed_nonglobal_reg_set;
HARD_REG_SET x_regs_invalidated_by_call;
int x_reg_alloc_order[76];
int x_inv_reg_alloc_order[76];
HARD_REG_SET x_reg_class_contents[((int) LIM_REG_CLASSES)];
bool x_class_only_fixed_regs[((int) LIM_REG_CLASSES)];
unsigned int x_reg_class_size[((int) LIM_REG_CLASSES)];
enum reg_class x_reg_class_subclasses[((int) LIM_REG_CLASSES)][((int) LIM_REG_CLASSES)];
enum reg_class x_reg_class_subunion[((int) LIM_REG_CLASSES)][((int) LIM_REG_CLASSES)];
enum reg_class x_reg_class_superunion[((int) LIM_REG_CLASSES)][((int) LIM_REG_CLASSES)];
const char *x_reg_names[76];
hash_table <simplifiable_subregs_hasher> *x_simplifiable_subregs;
};
extern struct target_hard_regs default_target_hard_regs;
extern struct target_hard_regs *this_target_hard_regs;
# 507 "/home/giulianob/gcc_git_gnu/gcc/gcc/hard-reg-set.h"
extern const char * reg_class_names[];
# 54 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.h" 2
struct cumulative_args_t { void *magic; void *p; };
# 72 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.h"
enum print_switch_type
{
SWITCH_TYPE_PASSED,
SWITCH_TYPE_ENABLED,
SWITCH_TYPE_DESCRIPTIVE,
SWITCH_TYPE_LINE_START,
SWITCH_TYPE_LINE_END
};
enum by_pieces_operation
{
CLEAR_BY_PIECES,
MOVE_BY_PIECES,
SET_BY_PIECES,
STORE_BY_PIECES,
COMPARE_BY_PIECES
};
extern unsigned long by_pieces_ninsns (unsigned long,
unsigned int,
unsigned int,
by_pieces_operation);
typedef int (* print_switch_fn_type) (print_switch_type, const char *);
extern int elf_record_gcc_switches (print_switch_type type, const char *);
extern bool target_default_pointer_address_modes_p (void);
extern unsigned int get_move_ratio (bool);
struct stdarg_info;
struct spec_info_def;
struct hard_reg_set_container;
struct cgraph_node;
struct cgraph_simd_clone;
struct secondary_reload_info
{
int icode;
int extra_cost;
struct secondary_reload_info *prev_sri;
int t_icode;
};
struct _dep;
struct ddg;
class loop;
struct noce_if_info;
class ao_ref;
class _stmt_vec_info;
class function_arg_info;
class predefined_function_abi;
extern tree stmt_vectype (class _stmt_vec_info *);
extern bool stmt_in_inner_loop_p (class vec_info *, class _stmt_vec_info *);
struct asm_int_op
{
const char *hi;
const char *psi;
const char *si;
const char *pdi;
const char *di;
const char *pti;
const char *ti;
};
enum vect_cost_for_stmt
{
scalar_stmt,
scalar_load,
scalar_store,
vector_stmt,
vector_load,
vector_gather_load,
unaligned_load,
unaligned_store,
vector_store,
vector_scatter_store,
vec_to_scalar,
scalar_to_vec,
cond_branch_not_taken,
cond_branch_taken,
vec_perm,
vec_promote_demote,
vec_construct
};
enum vect_cost_model_location {
vect_prologue = 0,
vect_body = 1,
vect_epilogue = 2
};
class vec_perm_indices;
typedef vec<machine_mode> vector_modes;
typedef auto_vec<machine_mode, 8> auto_vector_modes;
enum omp_device_kind_arch_isa {
omp_device_kind,
omp_device_arch,
omp_device_isa
};
const unsigned int VECT_COMPARE_COSTS = 1U << 0;
enum type_context_kind {
TCTX_SIZEOF,
TCTX_ALIGNOF,
TCTX_STATIC_STORAGE,
TCTX_THREAD_STORAGE,
TCTX_FIELD,
TCTX_ARRAY_ELEMENT,
TCTX_POINTER_ARITH,
TCTX_ALLOCATION,
TCTX_DEALLOCATION,
TCTX_EXCEPTIONS,
TCTX_CAPTURE_BY_COPY
};
extern bool verify_type_context (location_t, type_context_kind, const_tree,
bool = false);
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-hooks-macros.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def" 2
struct gcc_target {
struct asm_out {
const char * open_paren;
const char * close_paren;
const char * byte_op;
# 71 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
struct asm_int_op aligned_op;
struct asm_int_op unaligned_op;
bool (* integer) (rtx x, unsigned int size, int aligned_p);
# 97 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* post_cfi_startproc) (FILE *, tree);
# 110 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* decl_end) (void);
void (* globalize_label) (FILE *stream, const char *name);
# 130 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* globalize_decl_name) (FILE *stream, tree decl);
# 140 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* assemble_undefined_decl) (FILE *stream, const char *name, const_tree decl);
# 154 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* emit_unwind_label) (FILE *stream, tree decl, int for_eh, int empty);
# 169 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* emit_except_table_label) (FILE *stream);
# 180 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* emit_except_personality) (rtx personality);
# 189 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* unwind_emit) (FILE *stream, rtx_insn *insn);
bool unwind_emit_before_insn;
# 206 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* generate_internal_label) (char *buf, const char *prefix, unsigned long labelno);
void (* internal_label) (FILE *stream, const char *prefix, unsigned long labelno);
# 233 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* declare_constant_name) (FILE *file, const char *name, const_tree expr, long size);
# 250 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* ttype) (rtx sym);
# 261 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* assemble_visibility) (tree decl, int visibility);
void (* print_patchable_function_entry) (FILE *file, unsigned long patch_area_size, bool record_p);
# 281 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* function_prologue) (FILE *file);
# 329 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* function_end_prologue) (FILE *file);
# 339 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* function_begin_epilogue) (FILE *file);
# 349 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* function_epilogue) (FILE *file);
# 399 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_sections) (void);
# 414 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* named_section) (const char *name, unsigned int flags, tree decl);
# 426 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* elf_flags_numeric) (unsigned int flags, unsigned int *num);
# 447 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
section * (* function_section) (tree decl, enum node_frequency freq, bool startup, bool exit);
# 460 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* function_switched_text_sections) (FILE *file, tree decl, bool new_is_cold);
# 474 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* reloc_rw_mask) (void);
# 490 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* generate_pic_addr_diff_vec) (void);
# 504 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
section * (* select_section) (tree exp, int reloc, unsigned long align);
# 522 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
section * (* select_rtx_section) (machine_mode mode, rtx x, unsigned long align);
# 538 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* unique_section) (tree decl, int reloc);
# 553 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
section * (* function_rodata_section) (tree decl);
# 566 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * mergeable_rodata_prefix;
section * (* tm_clone_table_section) (void);
void (* constructor) (rtx symbol, int priority);
# 598 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* destructor) (rtx symbol, int priority);
# 609 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* output_mi_thunk) (FILE *file, tree thunk_fndecl, long delta, long vcall_offset, tree function);
# 660 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* can_output_mi_thunk) (const_tree thunk_fndecl, long delta, long vcall_offset, const_tree function);
# 673 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* file_start) (void);
# 685 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* file_end) (void);
# 694 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* lto_start) (void);
# 704 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* lto_end) (void);
# 714 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* code_end) (void);
# 726 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* external_libcall) (rtx symref);
# 736 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* mark_decl_preserved) (const char *symbol);
# 745 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* record_gcc_switches) (print_switch_type type, const char *text);
# 797 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * record_gcc_switches_section;
void (* output_anchor) (rtx x);
# 819 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* output_ident) (const char *name);
# 829 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* output_dwarf_dtprel) (FILE *file, int size, rtx x);
void (* final_postscan_insn) (FILE *file, rtx_insn *insn, rtx *opvec, int noperands);
# 853 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* trampoline_template) (FILE *f);
# 867 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* output_source_filename) (FILE *file, const char *name);
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* output_addr_const_extra) (FILE *file, rtx x);
# 900 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* print_operand) (FILE *file, rtx x, int code);
# 909 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* print_operand_address) (FILE *file, machine_mode mode, rtx addr);
# 919 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* print_operand_punct_valid_p) (unsigned char code);
tree (* mangle_assembler_name) (const char *name);
# 937 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} asm_out ;
struct sched {
int (* adjust_cost) (rtx_insn *insn, int dep_type1, rtx_insn *dep_insn, int cost, unsigned int dw);
# 967 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* adjust_priority) (rtx_insn *insn, int priority);
# 979 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* issue_rate) (void);
# 994 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* variable_issue) (FILE *file, int verbose, rtx_insn *insn, int more);
# 1010 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init) (FILE *file, int verbose, int max_ready);
# 1022 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* finish) (FILE *file, int verbose);
# 1033 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_global) (FILE *file, int verbose, int old_max_uid);
# 1042 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* finish_global) (FILE *file, int verbose);
# 1051 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* reorder) (FILE *file, int verbose, rtx_insn **ready, int *n_readyp, int clock);
# 1069 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* reorder2) (FILE *file, int verbose, rtx_insn **ready, int *n_readyp, int clock);
# 1081 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* macro_fusion_p) (void);
bool (* macro_fusion_pair_p) (rtx_insn *prev, rtx_insn *curr);
# 1099 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* dependencies_evaluation_hook) (rtx_insn *head, rtx_insn *tail);
# 1120 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_dfa_pre_cycle_insn) (void);
rtx (* dfa_pre_cycle_insn) (void);
# 1136 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_dfa_post_cycle_insn) (void);
rtx_insn * (* dfa_post_cycle_insn) (void);
# 1154 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* dfa_pre_advance_cycle) (void);
void (* dfa_post_advance_cycle) (void);
# 1177 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* first_cycle_multipass_dfa_lookahead) (void);
# 1211 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* first_cycle_multipass_dfa_lookahead_guard) (rtx_insn *insn, int ready_index);
# 1237 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* first_cycle_multipass_begin) (void *data, signed char *ready_try, int n_ready, bool first_cycle_insn_p);
# 1254 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* first_cycle_multipass_issue) (void *data, signed char *ready_try, int n_ready, rtx_insn *insn, const void *prev_data);
# 1269 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* first_cycle_multipass_backtrack) (const void *data, signed char *ready_try, int n_ready);
# 1283 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* first_cycle_multipass_end) (const void *data);
# 1294 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* first_cycle_multipass_init) (void *data);
# 1304 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* first_cycle_multipass_fini) (void *data);
# 1320 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* dfa_new_cycle) (FILE *dump, int verbose, rtx_insn *insn, int last_clock, int clock, int *sort_p);
# 1345 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* is_costly_dependence) (struct _dep *_dep, int cost, int distance);
# 1370 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* h_i_d_extended) (void);
# 1380 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void * (* alloc_sched_context) (void);
void (* init_sched_context) (void *tc, bool clean_p);
void (* set_sched_context) (void *tc);
void (* clear_sched_context) (void *tc);
void (* free_sched_context) (void *tc);
# 1421 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* speculate_insn) (rtx_insn *insn, unsigned int dep_status, rtx *new_pat);
# 1436 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* needs_block_p) (unsigned int dep_status);
# 1450 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* gen_spec_check) (rtx_insn *insn, rtx_insn *label, unsigned int ds);
# 1465 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* set_sched_flags) (struct spec_info_def *spec_info);
unsigned int (* get_insn_spec_ds) (rtx_insn *insn);
unsigned int (* get_insn_checked_ds) (rtx_insn *insn);
bool (* can_speculate_insn) (rtx_insn *insn);
# 1492 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* skip_rtx_p) (const_rtx x);
# 1502 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* sms_res_mii) (struct ddg *g);
# 1515 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* dispatch_do) (rtx_insn *insn, int x);
# 1525 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* dispatch) (rtx_insn *insn, int x);
bool exposed_pipeline;
# 1542 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* reassociation_width) (unsigned int opc, machine_mode mode);
# 1551 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* fusion_priority) (rtx_insn *insn, int max_pri, int *fusion_pri, int *pri);
# 1628 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} sched ;
struct simd_clone {
int (* compute_vecsize_and_simdlen) (struct cgraph_node *, struct cgraph_simd_clone *, tree, int);
# 1644 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* adjust) (struct cgraph_node *);
int (* usable) (struct cgraph_node *);
} simd_clone ;
struct simt {
int (* vf) (void);
} simt ;
struct omp {
int (* device_kind_arch_isa) (enum omp_device_kind_arch_isa trait, const char *name);
} omp ;
struct goacc {
bool (* validate_dims) (tree decl, int *dims, int fn_level, unsigned used);
# 1707 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* dim_limit) (int axis);
bool (* fork_join) (gcall *call, const int *dims, bool is_fork);
# 1726 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* reduction) (gcall *call);
# 1737 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} goacc ;
struct vectorize {
tree (* builtin_mask_for_load) (void);
# 1779 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* builtin_vectorized_function) (unsigned code, tree vec_type_out, tree vec_type_in);
# 1791 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* builtin_md_vectorized_function) (tree fndecl, tree vec_type_out, tree vec_type_in);
# 1803 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* builtin_vectorization_cost) (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign);
poly_uint64 (* preferred_vector_alignment) (const_tree type);
# 1827 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* vector_alignment_reachable) (const_tree type, bool is_packed);
bool (* vec_perm_const) (machine_mode mode, rtx output, rtx in0, rtx in1, const vec_perm_indices &sel);
# 1859 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* support_vector_misalignment) (machine_mode mode, const_tree type, int misalignment, bool is_packed);
# 1872 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
machine_mode (* preferred_simd_mode) (scalar_mode mode);
# 1883 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
machine_mode (* split_reduction) (machine_mode);
# 1895 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* autovectorize_vector_modes) (vector_modes *modes, bool all);
# 1929 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
opt_machine_mode (* related_mode) (machine_mode vector_mode, scalar_mode element_mode, poly_uint64 nunits);
# 1957 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
opt_machine_mode (* get_mask_mode) (machine_mode mode);
# 1974 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* empty_mask_is_expensive) (unsigned ifn);
# 1984 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* builtin_gather) (const_tree mem_vectype, const_tree index_type, int scale);
# 1996 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* builtin_scatter) (const_tree vectype, const_tree index_type, int scale);
# 2008 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void * (* init_cost) (class loop *loop_info);
# 2023 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned (* add_stmt_cost) (class vec_info *, void *data, int count, enum vect_cost_for_stmt kind, class _stmt_vec_info *stmt_info, tree vectype, int misalign, enum vect_cost_model_location where);
# 2040 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* finish_cost) (void *data, unsigned *prologue_cost, unsigned *body_cost, unsigned *epilogue_cost);
# 2052 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* destroy_cost_data) (void *data);
# 2061 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} vectorize ;
tree (* preferred_else_value) (unsigned ifn, tree type, unsigned nops, tree *ops);
# 2085 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* record_offload_symbol) (tree);
long absolute_biggest_alignment;
# 2103 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* override_options_after_change) (void);
# 2115 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
char * (* offload_options) (void);
# 2124 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
scalar_int_mode (* eh_return_filter_mode) (void);
scalar_int_mode (* libgcc_cmp_return_mode) (void);
# 2141 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
scalar_int_mode (* libgcc_shift_count_mode) (void);
# 2151 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
scalar_int_mode (* unwind_word_mode) (void);
tree (* merge_decl_attributes) (tree olddecl, tree newdecl);
# 2184 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* merge_type_attributes) (tree type1, tree type2);
# 2197 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const struct attribute_spec * attribute_table;
# 2208 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* attribute_takes_identifier_p) (const_tree name);
# 2221 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* comp_type_attributes) (const_tree type1, const_tree type2);
# 2232 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* set_default_type_attributes) (tree type);
void (* insert_attributes) (tree node, tree *attr_ptr);
# 2256 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* handle_generic_attribute) (tree *node, tree name, tree args, int flags, bool *no_add_attrs);
# 2268 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* function_attribute_inlinable_p) (const_tree fndecl);
# 2280 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* ms_bitfield_layout_p) (const_tree record_type);
# 2313 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* words_big_endian) (void);
bool (* float_words_big_endian) (void);
bool (* float_exceptions_rounding_supported_p) (void);
# 2339 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* decimal_float_supported_p) (void);
bool (* fixed_point_supported_p) (void);
bool (* align_anon_bitfield) (void);
# 2364 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* narrow_volatile_bitfield) (void);
# 2375 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_builtins) (void);
# 2399 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* builtin_decl) (unsigned code, bool initialize_p);
# 2411 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget, machine_mode mode, int ignore);
# 2431 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* resolve_overloaded_builtin) (unsigned int loc, tree fndecl, void *arglist);
# 2444 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* check_builtin_call) (location_t loc, vec<location_t> arg_loc, tree fndecl, tree orig_fndecl, unsigned int nargs, tree *args);
# 2464 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* fold_builtin) (tree fndecl, int n_args, tree *argp, bool ignore);
# 2477 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* gimple_fold_builtin) (gimple_stmt_iterator *gsi);
# 2494 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* compare_version_priority) (tree decl1, tree decl2);
# 2508 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* generate_version_dispatcher_body) (void *arg);
# 2520 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* get_function_versions_dispatcher) (void *decl);
# 2530 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* builtin_reciprocal) (tree fndecl);
# 2541 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* mangle_type) (const_tree type);
# 2578 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_libfuncs) (void);
# 2591 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool libfunc_gnu_prefix;
# 2604 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* section_type_flags) (tree decl, const char *name, int reloc);
# 2618 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* libc_has_function) (enum function_class fn_class);
bool (* libc_has_fast_function) (int fcode);
# 2634 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* cannot_modify_jumps_p) (void);
# 2652 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* can_follow_jump) (const rtx_insn *follower, const rtx_insn *followee);
# 2663 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* have_conditional_execution) (void);
rtx (* gen_ccmp_first) (rtx_insn **prep_seq, rtx_insn **gen_seq, int code, tree op0, tree op1);
# 2683 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* gen_ccmp_next) (rtx_insn **prep_seq, rtx_insn **gen_seq, rtx prev, int cmp_code, tree op0, tree op1, int bit_code);
# 2701 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned (* loop_unroll_adjust) (unsigned nunroll, class loop *loop);
# 2713 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* legitimate_constant_p) (machine_mode mode, rtx x);
# 2724 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* cannot_force_const_mem) (machine_mode mode, rtx x);
# 2740 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* cannot_copy_insn_p) (rtx_insn *);
bool (* commutative_p) (const_rtx x, int outer_code);
# 2757 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* mode_dependent_address_p) (const_rtx addr, addr_space_t addrspace);
# 2778 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* legitimize_address) (rtx x, rtx oldx, machine_mode mode);
# 2804 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* delegitimize_address) (rtx x);
# 2818 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* const_not_ok_for_debug_p) (rtx x);
bool (* legitimate_address_p) (machine_mode mode, rtx x, bool strict);
# 2894 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* use_blocks_for_constant_p) (machine_mode mode, const_rtx x);
# 2905 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* use_blocks_for_decl_p) (const_tree decl);
# 2915 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long min_anchor_offset;
long max_anchor_offset;
bool (* use_anchors_for_symbol_p) (const_rtx x);
# 2944 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* has_ifunc_p) (void);
# 2955 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* function_ok_for_sibcall) (tree decl, tree exp);
# 2973 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* set_current_function) (tree decl);
# 2994 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* in_small_data_p) (const_tree exp);
# 3003 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* binds_local_p) (const_tree exp);
# 3016 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* profile_before_prologue) (void);
# 3026 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* keep_leaf_when_profiled) (void);
# 3040 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* mangle_decl_assembler_name) (tree decl, tree id);
# 3054 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* encode_section_info) (tree decl, rtx rtl, int new_decl_p);
# 3095 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* strip_name_encoding) (const char *name);
# 3105 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned long (* shift_truncation_mask) (machine_mode mode);
# 3134 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* min_divisions_for_recip_mul) (machine_mode mode);
# 3145 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* truly_noop_truncation) (poly_uint64 outprec, poly_uint64 inprec);
# 3166 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* mode_rep_extended) (scalar_int_mode mode, scalar_int_mode rep_mode);
# 3196 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* setjmp_preserves_nonvolatile_regs_p) (void);
# 3212 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* valid_pointer_mode) (scalar_int_mode mode);
# 3221 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* ref_may_alias_errno) (ao_ref *ref);
# 3234 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
struct addr_space {
scalar_int_mode (* pointer_mode) (addr_space_t address_space);
# 3246 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
scalar_int_mode (* address_mode) (addr_space_t address_space);
# 3256 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* valid_pointer_mode) (scalar_int_mode mode, addr_space_t as);
# 3270 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* legitimate_address_p) (machine_mode mode, rtx exp, bool strict, addr_space_t as);
# 3284 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* legitimize_address) (rtx x, rtx oldx, machine_mode mode, addr_space_t as);
# 3294 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* subset_p) (addr_space_t subset, addr_space_t superset);
# 3307 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* zero_address_valid) (addr_space_t as);
rtx (* convert) (rtx op, tree from_type, tree to_type);
# 3327 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* debug) (addr_space_t as);
void (* diagnose_usage) (addr_space_t as, location_t loc);
# 3348 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} addr_space ;
void (* lower_local_decl_alignment) (tree decl);
long (* static_rtx_alignment) (machine_mode mode);
# 3369 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long (* constant_alignment) (const_tree constant, long basic_align);
# 3384 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
machine_mode (* translate_mode_attribute) (machine_mode mode);
# 3397 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* scalar_mode_supported_p) (scalar_mode mode);
# 3414 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* vector_mode_supported_p) (machine_mode mode);
bool (* compatible_vector_types_p) (const_tree type1, const_tree type2);
# 3445 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long (* vector_alignment) (const_tree type);
# 3455 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
opt_machine_mode (* array_mode) (machine_mode mode, unsigned long nelems);
# 3473 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* array_mode_supported_p) (machine_mode mode, unsigned long nelems);
# 3503 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* libgcc_floating_mode_supported_p) (scalar_float_mode mode);
# 3513 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
opt_scalar_float_mode (* floatn_mode) (int n, bool extended);
# 3533 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* floatn_builtin_p) (int func);
# 3548 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* register_move_cost) (machine_mode mode, reg_class_t from, reg_class_t to);
# 3574 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* memory_move_cost) (machine_mode mode, reg_class_t rclass, bool in);
# 3600 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* use_by_pieces_infrastructure_p) (unsigned long size, unsigned int alignment, enum by_pieces_operation op, bool speed_p);
# 3638 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* compare_by_pieces_branch_ratio) (machine_mode mode);
# 3650 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* slow_unaligned_access) (machine_mode mode, unsigned int align);
# 3669 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* optab_supported_p) (int op, machine_mode mode1, machine_mode mode2, optimization_type opt_type);
# 3690 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* small_register_classes_for_mode_p) (machine_mode mode);
# 3726 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int flags_regnum;
# 3738 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* rtx_costs) (rtx x, machine_mode mode, int outer_code, int opno, int *total, bool speed);
# 3774 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* address_cost) (rtx address, machine_mode mode, addr_space_t as, bool speed);
# 3812 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* insn_cost) (rtx_insn *insn, bool speed);
# 3827 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* max_noce_ifcvt_seq_cost) (edge e);
# 3851 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* noce_conversion_profitable_p) (rtx_insn *seq, struct noce_if_info *if_info);
# 3861 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* new_address_profitable_p) (rtx memref, rtx_insn * insn, rtx new_addr);
# 3870 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long (* estimated_poly_value) (poly_int64 val);
# 3880 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* no_speculation_in_delay_slots_p) (void);
# 3892 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* allocate_initial_value) (rtx hard_reg);
# 3917 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* unspec_may_trap_p) (const_rtx x, unsigned flags);
# 3934 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* dwarf_register_span) (rtx reg);
# 3947 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
machine_mode (* dwarf_frame_reg_mode) (int regno);
# 3960 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* init_dwarf_reg_sizes_extra) (tree address);
# 3978 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* fixed_condition_code_regs) (unsigned int *p1, unsigned int *p2);
# 4000 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
machine_mode (* cc_modes_compatible) (machine_mode m1, machine_mode m2);
# 4017 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* machine_dependent_reorg) (void);
# 4033 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* build_builtin_va_list) (void);
int (* enum_va_list_p) (int idx, const char **pname, tree *ptree);
# 4058 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* fn_abi_va_list) (tree fndecl);
# 4067 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* canonical_va_list_type) (tree type);
# 4076 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* expand_builtin_va_start) (tree valist, rtx nextarg);
tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p);
# 4096 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void * (* get_pch_validity) (size_t *sz);
const char * (* pch_valid_p) (const void *data, size_t sz);
# 4121 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* prepare_pch_save) (void);
# 4133 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* check_pch_target_flags) (int pch_flags);
# 4145 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* default_short_enums) (void);
# 4158 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* builtin_setjmp_frame_value) (void);
# 4170 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx_insn * (* md_asm_adjust) (vec<rtx>& outputs, vec<rtx>& inputs, vec<const char *>& constraints, vec<rtx>& clobbers, HARD_REG_SET& clobbered_regs);
# 4190 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* dwarf_calling_convention) (const_tree function);
# 4205 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* dwarf_handle_frame_unspec) (const char *label, rtx pattern, int index);
# 4222 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* dwarf_poly_indeterminate_value) (unsigned int i, unsigned int *factor, int *offset);
# 4238 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const gimple *stmt);
# 4248 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* stack_protect_guard) (void);
# 4263 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* stack_protect_fail) (void);
# 4277 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* stack_protect_runtime_enabled_p) (void);
bool (* have_speculation_safe_value) (bool active);
# 4303 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* speculation_safe_value) (machine_mode mode, rtx result, rtx val, rtx failval);
# 4323 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* predict_doloop_p) (class loop *loop);
# 4333 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool have_count_reg_decr_p;
int64_t doloop_cost_for_generic;
# 4353 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int64_t doloop_cost_for_address;
# 4366 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* can_use_doloop_p) (const widest_int &iterations, const widest_int &iterations_max, unsigned int loop_depth, bool entered_at_top);
# 4385 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* invalid_within_doloop) (const rtx_insn *insn);
# 4401 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* legitimate_combined_insn) (rtx_insn *insn);
bool (* valid_dllimport_attribute_p) (const_tree decl);
# 4419 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned long const_anchor;
# 4439 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned long (* memmodel_check) (unsigned long val);
# 4448 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned long (* asan_shadow_offset) (void);
# 4458 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
struct calls {
machine_mode (* promote_function_mode) (const_tree type, machine_mode mode, int *punsignedp, const_tree funtype, int for_return);
# 4485 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* promote_prototypes) (const_tree fntype);
# 4495 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* struct_value_rtx) (tree fndecl, int incoming);
# 4520 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool omit_struct_return_reg;
# 4529 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* return_in_memory) (const_tree type, const_tree fntype);
# 4550 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* return_in_msb) (const_tree type);
# 4568 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* pass_by_reference) (cumulative_args_t cum, const function_arg_info &arg);
# 4583 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* expand_builtin_saveregs) (void);
# 4594 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* setup_incoming_varargs) (cumulative_args_t args_so_far, const function_arg_info &arg, int *pretend_args_size, int second_time);
# 4631 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* load_bounds_for_arg) (rtx slot, rtx arg, rtx slot_no);
# 4643 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* store_bounds_for_arg) (rtx arg, rtx slot, rtx bounds, rtx slot_no);
# 4655 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* load_returned_bounds) (rtx slot);
void (* store_returned_bounds) (rtx slot, rtx bounds);
void (* call_args) (rtx, tree);
# 4687 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* end_call_args) (void);
# 4697 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* strict_argument_naming) (cumulative_args_t ca);
# 4717 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* pretend_outgoing_varargs_named) (cumulative_args_t ca);
# 4730 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* split_complex_arg) (const_tree type);
# 4748 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* must_pass_in_stack) (const function_arg_info &arg);
# 4760 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* callee_copies) (cumulative_args_t cum, const function_arg_info &arg);
# 4779 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* arg_partial_bytes) (cumulative_args_t cum, const function_arg_info &arg);
# 4803 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* function_arg_advance) (cumulative_args_t ca, const function_arg_info &arg);
# 4817 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long (* function_arg_offset) (machine_mode mode, const_tree type);
# 4827 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
pad_direction (* function_arg_padding) (machine_mode mode, const_tree type);
# 4849 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* function_arg) (cumulative_args_t ca, const function_arg_info &arg);
# 4902 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* function_incoming_arg) (cumulative_args_t ca, const function_arg_info &arg);
# 4924 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* function_arg_boundary) (machine_mode mode, const_tree type);
unsigned int (* function_arg_round_boundary) (machine_mode mode, const_tree type);
# 4943 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* invalid_arg_for_unprototyped_fn) (const_tree typelist, const_tree funcdecl, const_tree val);
# 4953 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* function_value) (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing);
# 5001 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* libcall_value) (machine_mode mode, const_rtx fun);
# 5016 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* function_value_regno_p) (const unsigned int regno);
# 5033 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const predefined_function_abi & (* fntype_abi) (const_tree type);
# 5042 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const predefined_function_abi & (* insn_callee_abi) (const rtx_insn *insn);
# 5056 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* internal_arg_pointer) (void);
void (* update_stack_boundary) (void);
rtx (* get_drap_rtx) (void);
# 5082 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* allocate_stack_slots_for_args) (void);
# 5097 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* static_chain) (const_tree fndecl_or_type, bool incoming_p);
# 5123 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* trampoline_init) (rtx m_tramp, tree fndecl, rtx static_chain);
# 5145 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
rtx (* trampoline_adjust_address) (rtx addr);
# 5156 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int custom_function_descriptors;
# 5180 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
poly_int64 (* return_pops_args) (tree fundecl, tree funtype, poly_int64 size);
# 5222 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
fixed_size_mode (* get_raw_result_mode) (int regno);
# 5232 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
fixed_size_mode (* get_raw_arg_mode) (int regno);
# 5241 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* empty_record_p) (const_tree type);
void (* warn_parameter_passing_abi) (cumulative_args_t ca, tree type);
} calls ;
bool (* use_pseudo_pic_reg) (void);
void (* init_pic_reg) (void);
# 5274 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* invalid_conversion) (const_tree fromtype, const_tree totype);
# 5284 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* invalid_unary_op) (int op, const_tree type);
# 5295 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* invalid_binary_op) (int op, const_tree type1, const_tree type2);
# 5307 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* promoted_type) (const_tree type);
# 5321 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* convert_to_type) (tree type, tree expr);
# 5332 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* verify_type_context) (location_t loc, type_context_kind context, const_tree type, bool silent_p);
# 5348 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* can_change_mode_class) (machine_mode from, machine_mode to, reg_class_t rclass);
# 5381 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
reg_class_t (* ira_change_pseudo_allocno_class) (int, reg_class_t, reg_class_t);
# 5391 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* lra_p) (void);
# 5401 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* register_priority) (int);
# 5417 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* register_usage_leveling_p) (void);
# 5432 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* different_addr_displacement_p) (void);
# 5445 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
reg_class_t (* spill_class) (reg_class_t, machine_mode);
# 5455 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* additional_allocno_class_p) (reg_class_t);
# 5466 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
scalar_int_mode (* cstore_mode) (enum insn_code icode);
# 5478 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* compute_pressure_classes) (enum reg_class *pressure_classes);
# 5488 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* member_type_forces_blk) (const_tree field, machine_mode mode);
# 5504 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* expand_divmod_libfunc) (rtx libfunc, machine_mode mode, rtx op0, rtx op1, rtx *quot, rtx *rem);
reg_class_t (* secondary_reload) (bool in_p, rtx x, reg_class_t reload_class, machine_mode reload_mode, secondary_reload_info *sri);
# 5602 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* secondary_memory_needed) (machine_mode mode, reg_class_t class1, reg_class_t class2);
# 5614 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
machine_mode (* secondary_memory_needed_mode) (machine_mode mode);
# 5640 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
reg_class_t (* preferred_reload_class) (rtx x, reg_class_t rclass);
# 5679 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
reg_class_t (* preferred_output_reload_class) (rtx x, reg_class_t rclass);
# 5693 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* select_early_remat_modes) (sbitmap modes);
# 5706 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* class_likely_spilled_p) (reg_class_t rclass);
# 5726 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned char (* class_max_nregs) (reg_class_t rclass, machine_mode mode);
# 5745 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
reg_class_t (* preferred_rename_class) (reg_class_t rclass);
# 5762 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* cannot_substitute_mem_equiv_p) (rtx subst);
# 5776 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* legitimize_address_displacement) (rtx *offset1, rtx *offset2, poly_int64 orig_offset, machine_mode mode);
# 5792 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* expand_to_rtl_hook) (void);
# 5806 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* instantiate_decls) (void);
unsigned int (* hard_regno_nregs) (unsigned int regno, machine_mode mode);
# 5826 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* hard_regno_mode_ok) (unsigned int regno, machine_mode mode);
# 5885 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* modes_tieable_p) (machine_mode mode1, machine_mode mode2);
# 5906 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* hard_regno_scratch_ok) (unsigned int regno);
# 5918 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* hard_regno_call_part_clobbered) (unsigned int abi_id, unsigned int regno, machine_mode mode);
# 5942 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * (* get_multilib_abi_name) (void);
unsigned int (* case_values_threshold) (void);
# 5959 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long (* starting_frame_offset) (void);
# 5970 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* compute_frame_layout) (void);
# 5982 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* frame_pointer_required) (void);
# 6011 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* can_eliminate) (const int from_reg, const int to_reg);
# 6026 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* conditional_register_usage) (void);
# 6059 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
long (* stack_clash_protection_alloca_probe_range) (void);
# 6076 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
struct c {
machine_mode (* mode_for_suffix) (char c);
enum flt_eval_method (* excess_precision) (enum excess_precision_type type);
# 6107 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} c ;
struct cxx {
tree (* guard_type) (void);
# 6124 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* guard_mask_bit) (void);
# 6133 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* get_cookie_size) (tree type);
# 6144 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* cookie_has_size) (void);
# 6153 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* import_export_class) (tree type, int import_export);
# 6164 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* cdtor_returns_this) (void);
# 6175 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* key_method_may_be_inline) (void);
# 6187 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* determine_class_data_visibility) (tree decl);
# 6203 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* class_data_always_comdat) (void);
# 6216 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* library_rtti_comdat) (void);
# 6226 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* use_aeabi_atexit) (void);
# 6236 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* use_atexit_for_cxa_atexit) (void);
# 6246 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* adjust_class_at_definition) (tree type);
tree (* decl_mangling_context) (const_tree decl);
} cxx ;
struct emutls {
const char * get_address;
const char * register_common;
# 6285 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
const char * var_section;
const char * tmpl_section;
const char * var_prefix;
const char * tmpl_prefix;
tree (* var_fields) (tree type, tree *name);
# 6324 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
tree (* var_init) (tree var, tree decl, tree tmpl_addr);
# 6335 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool var_align_fixed;
bool debug_form_tls_address;
} emutls ;
struct target_option_hooks {
bool (* valid_attribute_p) (tree fndecl, tree name, tree args, int flags);
# 6373 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* save) (struct cl_target_option *ptr, struct gcc_options *opts);
# 6383 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* restore) (struct gcc_options *opts, struct cl_target_option *ptr);
# 6392 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* post_stream_in) (struct cl_target_option *ptr);
# 6401 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* print) (FILE *file, int indent, struct cl_target_option *ptr);
# 6412 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* pragma_parse) (tree args, tree pop_target);
# 6422 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* override) (void);
# 6442 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* function_versions) (tree decl1, tree decl2);
# 6455 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* can_inline_p) (tree caller, tree callee);
# 6464 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* relayout_function) (tree fndecl);
} target_option ;
void (* extra_live_on_entry) (bitmap regs);
# 6489 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool call_fusage_contains_non_callee_clobbers;
# 6503 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* set_up_by_prologue) (struct hard_reg_set_container *);
# 6513 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool (* warn_func_return) (tree);
struct shrink_wrap {
sbitmap (* get_separate_components) (void);
# 6534 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
sbitmap (* components_for_bb) (basic_block);
void (* disqualify_components) (sbitmap components, edge e, sbitmap edge_components, bool is_prologue);
# 6551 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* emit_prologue_components) (sbitmap);
void (* emit_epilogue_components) (sbitmap);
void (* set_handled_components) (sbitmap);
# 6572 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
} shrink_wrap ;
enum unwind_info_type (* debug_unwind_info) (void);
# 6592 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
int (* reset_location_view) (rtx_insn *);
# 6611 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
void (* canonicalize_comparison) (int *code, rtx *op0, rtx *op1, bool op0_preserve_value);
# 6635 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* min_arithmetic_precision) (void);
# 6653 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned char atomic_test_and_set_trueval;
# 6663 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
unsigned int (* atomic_align_for_mode) (machine_mode mode);
void (* atomic_assign_expand_fenv) (tree *hold, tree *clear, tree *update);
# 6695 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool have_switchable_bss_sections;
# 6704 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool have_ctors_dtors;
bool have_tls;
bool have_srodata_section;
bool terminate_dw2_eh_frame_info;
# 6735 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool asm_file_start_app_off;
# 6752 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool asm_file_start_file_directive;
# 6762 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
bool arm_eabi_unwinder;
bool want_debug_pub_sections;
bool delay_sched2;
bool delay_vartrack;
bool no_register_allocation;
# 6798 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def"
struct mode_switching {
void (* emit) (int entity, int mode, int prev_mode, HARD_REG_SET regs_live);
int (* needed) (int entity, rtx_insn *insn);
int (* after) (int entity, int mode, rtx_insn *insn);
int (* entry) (int entity);
int (* exit) (int entity);
int (* priority) (int entity, int n);
} mode_switching ;
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-insns.def" 1
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-insns.def"
bool (* have_allocate_stack) (void);
bool (* have_atomic_test_and_set) (void);
bool (* have_builtin_longjmp) (void);
bool (* have_builtin_setjmp_receiver) (void);
bool (* have_builtin_setjmp_setup) (void);
bool (* have_canonicalize_funcptr_for_compare) (void);
bool (* have_call) (void);
bool (* have_call_pop) (void);
bool (* have_call_value) (void);
bool (* have_call_value_pop) (void);
bool (* have_casesi) (void);
bool (* have_check_stack) (void);
bool (* have_clear_cache) (void);
bool (* have_doloop_begin) (void);
bool (* have_doloop_end) (void);
bool (* have_eh_return) (void);
bool (* have_epilogue) (void);
bool (* have_exception_receiver) (void);
bool (* have_extv) (void);
bool (* have_extzv) (void);
bool (* have_indirect_jump) (void);
bool (* have_insv) (void);
bool (* have_jump) (void);
bool (* have_load_multiple) (void);
bool (* have_mem_thread_fence) (void);
bool (* have_memory_barrier) (void);
bool (* have_memory_blockage) (void);
bool (* have_movstr) (void);
bool (* have_nonlocal_goto) (void);
bool (* have_nonlocal_goto_receiver) (void);
bool (* have_oacc_dim_pos) (void);
bool (* have_oacc_dim_size) (void);
bool (* have_oacc_fork) (void);
bool (* have_oacc_join) (void);
bool (* have_omp_simt_enter) (void);
bool (* have_omp_simt_exit) (void);
bool (* have_omp_simt_lane) (void);
bool (* have_omp_simt_last_lane) (void);
bool (* have_omp_simt_ordered) (void);
bool (* have_omp_simt_vote_any) (void);
bool (* have_omp_simt_xchg_bfly) (void);
bool (* have_omp_simt_xchg_idx) (void);
bool (* have_prefetch) (void);
bool (* have_probe_stack) (void);
bool (* have_probe_stack_address) (void);
bool (* have_prologue) (void);
bool (* have_ptr_extend) (void);
bool (* have_reload_load_address) (void);
bool (* have_restore_stack_block) (void);
bool (* have_restore_stack_function) (void);
bool (* have_restore_stack_nonlocal) (void);
bool (* have_return) (void);
bool (* have_save_stack_block) (void);
bool (* have_save_stack_function) (void);
bool (* have_save_stack_nonlocal) (void);
bool (* have_sibcall) (void);
bool (* have_sibcall_epilogue) (void);
bool (* have_sibcall_value) (void);
bool (* have_simple_return) (void);
bool (* have_split_stack_prologue) (void);
bool (* have_split_stack_space_check) (void);
bool (* have_stack_protect_combined_set) (void);
bool (* have_stack_protect_set) (void);
bool (* have_stack_protect_combined_test) (void);
bool (* have_stack_protect_test) (void);
bool (* have_store_multiple) (void);
bool (* have_tablejump) (void);
bool (* have_trap) (void);
bool (* have_unique) (void);
bool (* have_untyped_call) (void);
bool (* have_untyped_return) (void);
# 6838 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-insns.def" 1
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-insns.def"
rtx_insn * (* gen_allocate_stack) (rtx x0, rtx x1);
rtx_insn * (* gen_atomic_test_and_set) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_builtin_longjmp) (rtx x0);
rtx_insn * (* gen_builtin_setjmp_receiver) (rtx x0);
rtx_insn * (* gen_builtin_setjmp_setup) (rtx x0);
rtx_insn * (* gen_canonicalize_funcptr_for_compare) (rtx x0, rtx x1);
rtx_insn * (* gen_call) (rtx x0, rtx opt1, rtx opt2, rtx opt3);
rtx_insn * (* gen_call_pop) (rtx x0, rtx opt1, rtx opt2, rtx opt3);
rtx_insn * (* gen_call_value) (rtx x0, rtx x1, rtx opt2, rtx opt3, rtx opt4);
rtx_insn * (* gen_call_value_pop) (rtx x0, rtx x1, rtx opt2, rtx opt3, rtx opt4);
rtx_insn * (* gen_casesi) (rtx x0, rtx x1, rtx x2, rtx x3, rtx x4);
rtx_insn * (* gen_check_stack) (rtx x0);
rtx_insn * (* gen_clear_cache) (rtx x0, rtx x1);
rtx_insn * (* gen_doloop_begin) (rtx x0, rtx x1);
rtx_insn * (* gen_doloop_end) (rtx x0, rtx x1);
rtx_insn * (* gen_eh_return) (rtx x0);
rtx_insn * (* gen_epilogue) (void);
rtx_insn * (* gen_exception_receiver) (void);
rtx_insn * (* gen_extv) (rtx x0, rtx x1, rtx x2, rtx x3);
rtx_insn * (* gen_extzv) (rtx x0, rtx x1, rtx x2, rtx x3);
rtx_insn * (* gen_indirect_jump) (rtx x0);
rtx_insn * (* gen_insv) (rtx x0, rtx x1, rtx x2, rtx x3);
rtx_insn * (* gen_jump) (rtx x0);
rtx_insn * (* gen_load_multiple) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_mem_thread_fence) (rtx x0);
rtx_insn * (* gen_memory_barrier) (void);
rtx_insn * (* gen_memory_blockage) (void);
rtx_insn * (* gen_movstr) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_nonlocal_goto) (rtx x0, rtx x1, rtx x2, rtx x3);
rtx_insn * (* gen_nonlocal_goto_receiver) (void);
rtx_insn * (* gen_oacc_dim_pos) (rtx x0, rtx x1);
rtx_insn * (* gen_oacc_dim_size) (rtx x0, rtx x1);
rtx_insn * (* gen_oacc_fork) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_oacc_join) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_omp_simt_enter) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_omp_simt_exit) (rtx x0);
rtx_insn * (* gen_omp_simt_lane) (rtx x0);
rtx_insn * (* gen_omp_simt_last_lane) (rtx x0, rtx x1);
rtx_insn * (* gen_omp_simt_ordered) (rtx x0, rtx x1);
rtx_insn * (* gen_omp_simt_vote_any) (rtx x0, rtx x1);
rtx_insn * (* gen_omp_simt_xchg_bfly) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_omp_simt_xchg_idx) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_prefetch) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_probe_stack) (rtx x0);
rtx_insn * (* gen_probe_stack_address) (rtx x0);
rtx_insn * (* gen_prologue) (void);
rtx_insn * (* gen_ptr_extend) (rtx x0, rtx x1);
rtx_insn * (* gen_reload_load_address) (rtx x0, rtx x1);
rtx_insn * (* gen_restore_stack_block) (rtx x0, rtx x1);
rtx_insn * (* gen_restore_stack_function) (rtx x0, rtx x1);
rtx_insn * (* gen_restore_stack_nonlocal) (rtx x0, rtx x1);
rtx_insn * (* gen_return) (void);
rtx_insn * (* gen_save_stack_block) (rtx x0, rtx x1);
rtx_insn * (* gen_save_stack_function) (rtx x0, rtx x1);
rtx_insn * (* gen_save_stack_nonlocal) (rtx x0, rtx x1);
rtx_insn * (* gen_sibcall) (rtx x0, rtx opt1, rtx opt2, rtx opt3);
rtx_insn * (* gen_sibcall_epilogue) (void);
rtx_insn * (* gen_sibcall_value) (rtx x0, rtx x1, rtx opt2, rtx opt3, rtx opt4);
rtx_insn * (* gen_simple_return) (void);
rtx_insn * (* gen_split_stack_prologue) (void);
rtx_insn * (* gen_split_stack_space_check) (rtx x0, rtx x1);
rtx_insn * (* gen_stack_protect_combined_set) (rtx x0, rtx x1);
rtx_insn * (* gen_stack_protect_set) (rtx x0, rtx x1);
rtx_insn * (* gen_stack_protect_combined_test) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_stack_protect_test) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_store_multiple) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_tablejump) (rtx x0, rtx x1);
rtx_insn * (* gen_trap) (void);
rtx_insn * (* gen_unique) (void);
rtx_insn * (* gen_untyped_call) (rtx x0, rtx x1, rtx x2);
rtx_insn * (* gen_untyped_return) (rtx x0, rtx x1);
# 6843 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-insns.def" 1
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-insns.def"
enum insn_code code_for_allocate_stack;
enum insn_code code_for_atomic_test_and_set;
enum insn_code code_for_builtin_longjmp;
enum insn_code code_for_builtin_setjmp_receiver;
enum insn_code code_for_builtin_setjmp_setup;
enum insn_code code_for_canonicalize_funcptr_for_compare;
enum insn_code code_for_call;
enum insn_code code_for_call_pop;
enum insn_code code_for_call_value;
enum insn_code code_for_call_value_pop;
enum insn_code code_for_casesi;
enum insn_code code_for_check_stack;
enum insn_code code_for_clear_cache;
enum insn_code code_for_doloop_begin;
enum insn_code code_for_doloop_end;
enum insn_code code_for_eh_return;
enum insn_code code_for_epilogue;
enum insn_code code_for_exception_receiver;
enum insn_code code_for_extv;
enum insn_code code_for_extzv;
enum insn_code code_for_indirect_jump;
enum insn_code code_for_insv;
enum insn_code code_for_jump;
enum insn_code code_for_load_multiple;
enum insn_code code_for_mem_thread_fence;
enum insn_code code_for_memory_barrier;
enum insn_code code_for_memory_blockage;
enum insn_code code_for_movstr;
enum insn_code code_for_nonlocal_goto;
enum insn_code code_for_nonlocal_goto_receiver;
enum insn_code code_for_oacc_dim_pos;
enum insn_code code_for_oacc_dim_size;
enum insn_code code_for_oacc_fork;
enum insn_code code_for_oacc_join;
enum insn_code code_for_omp_simt_enter;
enum insn_code code_for_omp_simt_exit;
enum insn_code code_for_omp_simt_lane;
enum insn_code code_for_omp_simt_last_lane;
enum insn_code code_for_omp_simt_ordered;
enum insn_code code_for_omp_simt_vote_any;
enum insn_code code_for_omp_simt_xchg_bfly;
enum insn_code code_for_omp_simt_xchg_idx;
enum insn_code code_for_prefetch;
enum insn_code code_for_probe_stack;
enum insn_code code_for_probe_stack_address;
enum insn_code code_for_prologue;
enum insn_code code_for_ptr_extend;
enum insn_code code_for_reload_load_address;
enum insn_code code_for_restore_stack_block;
enum insn_code code_for_restore_stack_function;
enum insn_code code_for_restore_stack_nonlocal;
enum insn_code code_for_return;
enum insn_code code_for_save_stack_block;
enum insn_code code_for_save_stack_function;
enum insn_code code_for_save_stack_nonlocal;
enum insn_code code_for_sibcall;
enum insn_code code_for_sibcall_epilogue;
enum insn_code code_for_sibcall_value;
enum insn_code code_for_simple_return;
enum insn_code code_for_split_stack_prologue;
enum insn_code code_for_split_stack_space_check;
enum insn_code code_for_stack_protect_combined_set;
enum insn_code code_for_stack_protect_set;
enum insn_code code_for_stack_protect_combined_test;
enum insn_code code_for_stack_protect_test;
enum insn_code code_for_store_multiple;
enum insn_code code_for_tablejump;
enum insn_code code_for_trap;
enum insn_code code_for_unique;
enum insn_code code_for_untyped_call;
enum insn_code code_for_untyped_return;
# 6848 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.def" 2
void (* run_target_selftests) (void);
} ;
# 277 "/home/giulianob/gcc_git_gnu/gcc/gcc/target.h" 2
extern struct gcc_target targetm;
static inline long
estimated_poly_value (poly_int64 x)
{
if (1 == 1)
return x.coeffs[0];
else
return targetm.estimated_poly_value (x);
}
static inline CUMULATIVE_ARGS *
get_cumulative_args (cumulative_args_t arg)
{
((void)(!(arg.magic == ((void *) &targetm.calls)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/target.h", 305, __FUNCTION__), 0 : 0));
return (CUMULATIVE_ARGS *) arg.p;
}
static inline cumulative_args_t
pack_cumulative_args (CUMULATIVE_ARGS *arg)
{
cumulative_args_t ret;
ret.magic = ((void *) &targetm.calls);
ret.p = (void *) arg;
return ret;
}
# 98 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 1
# 39 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
class predefined_function_abi;
# 48 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum rtx_code {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def" 1
# 81 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
UNKNOWN ,
VALUE ,
DEBUG_EXPR ,
EXPR_LIST ,
INSN_LIST ,
INT_LIST ,
# 126 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
SEQUENCE ,
ADDRESS ,
# 142 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
DEBUG_INSN ,
INSN ,
JUMP_INSN ,
CALL_INSN ,
JUMP_TABLE_DATA ,
BARRIER ,
CODE_LABEL ,
NOTE ,
# 194 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
COND_EXEC ,
PARALLEL ,
ASM_INPUT ,
# 219 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
ASM_OPERANDS ,
# 237 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
UNSPEC ,
UNSPEC_VOLATILE ,
ADDR_VEC ,
# 272 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
ADDR_DIFF_VEC ,
# 283 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
PREFETCH ,
# 295 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
SET ,
# 304 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
USE ,
# 313 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
CLOBBER ,
CALL ,
RETURN ,
SIMPLE_RETURN ,
EH_RETURN ,
TRAP_IF ,
CONST_INT ,
CONST_WIDE_INT ,
CONST_POLY_INT ,
CONST_FIXED ,
CONST_DOUBLE ,
CONST_VECTOR ,
CONST_STRING ,
CONST ,
PC ,
REG ,
SCRATCH ,
SUBREG ,
# 410 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
STRICT_LOW_PART ,
CONCAT ,
CONCATN ,
MEM ,
LABEL_REF ,
SYMBOL_REF ,
CC0 ,
# 456 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
IF_THEN_ELSE ,
COMPARE ,
PLUS ,
MINUS ,
NEG ,
MULT ,
SS_MULT ,
US_MULT ,
DIV ,
SS_DIV ,
US_DIV ,
MOD ,
UDIV ,
UMOD ,
AND ,
IOR ,
XOR ,
NOT ,
ASHIFT ,
ROTATE ,
ASHIFTRT ,
LSHIFTRT ,
ROTATERT ,
# 513 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
SMIN ,
SMAX ,
UMIN ,
UMAX ,
# 525 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
PRE_DEC ,
PRE_INC ,
POST_DEC ,
POST_INC ,
# 542 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
PRE_MODIFY ,
POST_MODIFY ,
NE ,
EQ ,
GE ,
GT ,
LE ,
LT ,
LTGT ,
GEU ,
GTU ,
LEU ,
LTU ,
UNORDERED ,
ORDERED ,
UNEQ ,
UNGE ,
UNGT ,
UNLE ,
UNLT ,
SIGN_EXTEND ,
ZERO_EXTEND ,
TRUNCATE ,
FLOAT_EXTEND ,
FLOAT_TRUNCATE ,
FLOAT ,
FIX ,
UNSIGNED_FLOAT ,
UNSIGNED_FIX ,
# 616 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
FRACT_CONVERT ,
UNSIGNED_FRACT_CONVERT ,
SAT_FRACT ,
UNSIGNED_SAT_FRACT ,
ABS ,
SQRT ,
BSWAP ,
FFS ,
CLRSB ,
CLZ ,
CTZ ,
POPCOUNT ,
PARITY ,
# 679 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.def"
SIGN_EXTRACT ,
ZERO_EXTRACT ,
HIGH ,
LO_SUM ,
VEC_MERGE ,
VEC_SELECT ,
VEC_CONCAT ,
VEC_DUPLICATE ,
VEC_SERIES ,
SS_PLUS ,
US_PLUS ,
SS_MINUS ,
SS_NEG ,
US_NEG ,
SS_ABS ,
SS_ASHIFT ,
US_ASHIFT ,
US_MINUS ,
SS_TRUNCATE ,
US_TRUNCATE ,
FMA ,
VAR_LOCATION ,
DEBUG_IMPLICIT_PTR ,
ENTRY_VALUE ,
DEBUG_PARAMETER_REF ,
DEBUG_MARKER ,
# 52 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 2
LAST_AND_UNUSED_RTX_CODE};
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum rtx_class {
RTX_COMPARE,
RTX_COMM_COMPARE,
RTX_BIN_ARITH,
RTX_COMM_ARITH,
RTX_UNARY,
RTX_EXTRA,
RTX_MATCH,
RTX_INSN,
RTX_OBJ,
RTX_CONST_OBJ,
RTX_TERNARY,
RTX_BITFIELD_OPS,
RTX_AUTOINC
};
# 106 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern const unsigned char rtx_length[((int) LAST_AND_UNUSED_RTX_CODE)];
extern const char * const rtx_name[((int) LAST_AND_UNUSED_RTX_CODE)];
extern const char * const rtx_format[((int) LAST_AND_UNUSED_RTX_CODE)];
extern const enum rtx_class rtx_class[((int) LAST_AND_UNUSED_RTX_CODE)];
extern const unsigned char rtx_code_size[((int) LAST_AND_UNUSED_RTX_CODE)];
extern const unsigned char rtx_next[((int) LAST_AND_UNUSED_RTX_CODE)];
struct addr_diff_vec_flags
{
unsigned min_align: 8;
unsigned base_after_vec: 1;
unsigned min_after_vec: 1;
unsigned max_after_vec: 1;
unsigned min_after_base: 1;
unsigned max_after_base: 1;
unsigned offset_unsigned: 1;
unsigned : 2;
unsigned scale : 8;
};
class mem_attrs
{
public:
mem_attrs ();
tree expr;
poly_int64 offset;
poly_int64 size;
alias_set_type alias;
unsigned int align;
unsigned char addrspace;
bool offset_known_p;
bool size_known_p;
};
# 193 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
class reg_attrs {
public:
tree decl;
poly_int64 offset;
};
union rtunion
{
int rt_int;
unsigned int rt_uint;
poly_uint16_pod rt_subreg;
const char *rt_str;
rtx rt_rtx;
rtvec rt_rtvec;
machine_mode rt_type;
addr_diff_vec_flags rt_addr_diff_vec_flags;
struct cselib_val *rt_cselib;
tree rt_tree;
basic_block rt_bb;
mem_attrs *rt_mem;
class constant_descriptor_rtx *rt_constant;
struct dw_cfi_node *rt_cfi;
};
struct reg_info {
unsigned int regno;
unsigned int nregs : 8;
unsigned int unused : 24;
reg_attrs *attrs;
};
struct block_symbol {
rtunion fld[2];
struct object_block *block;
long offset;
};
struct object_block {
section *sect;
unsigned int alignment;
long size;
# 267 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
vec<rtx, va_gc> *objects;
# 277 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
vec<rtx, va_gc> *anchors;
};
struct hwivec_def {
long elem[1];
};
struct const_poly_int_def {
trailing_wide_ints<1> coeffs;
};
# 309 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
struct
rtx_def {
enum rtx_code code: 16;
enum machine_mode mode : 8;
# 329 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
unsigned int jump : 1;
unsigned int call : 1;
# 348 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
unsigned int unchanging : 1;
# 362 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
unsigned int volatil : 1;
# 377 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
unsigned int in_struct : 1;
# 386 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
unsigned int used : 1;
# 395 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
unsigned frame_related : 1;
unsigned return_val : 1;
union {
unsigned int original_regno;
int insn_uid;
unsigned int symbol_ref_flags;
enum var_init_status var_location_status;
unsigned int num_elem;
struct
{
unsigned int npatterns : 16;
unsigned int nelts_per_pattern : 8;
unsigned int unused : 8;
} const_vector;
} u2;
union u {
rtunion fld[1];
long hwint[1];
struct reg_info reg;
struct block_symbol block_sym;
struct real_value rv;
struct fixed_value fv;
struct hwivec_def hwiv;
struct const_poly_int_def cpi;
} u;
};
struct rtx_expr_list : public rtx_def
{
private:
public:
rtx_expr_list *next () const;
rtx element () const;
};
template <>
template <>
inline bool
is_a_helper <rtx_expr_list *>::test (rtx rt)
{
return rt->code == EXPR_LIST;
}
struct rtx_insn_list : public rtx_def
{
private:
# 491 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
public:
rtx_insn_list *next () const;
rtx_insn *insn () const;
};
template <>
template <>
inline bool
is_a_helper <rtx_insn_list *>::test (rtx rt)
{
return rt->code == INSN_LIST;
}
struct rtx_sequence : public rtx_def
{
private:
public:
int len () const;
rtx element (int index) const;
rtx_insn *insn (int index) const;
};
template <>
template <>
inline bool
is_a_helper <rtx_sequence *>::test (rtx rt)
{
return rt->code == SEQUENCE;
}
template <>
template <>
inline bool
is_a_helper <const rtx_sequence *>::test (const_rtx rt)
{
return rt->code == SEQUENCE;
}
struct rtx_insn : public rtx_def
{
public:
# 565 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
bool deleted () const { return volatil; }
void set_deleted () { volatil = true; }
void set_undeleted () { volatil = false; }
};
struct rtx_debug_insn : public rtx_insn
{
};
struct rtx_nonjump_insn : public rtx_insn
{
};
struct rtx_jump_insn : public rtx_insn
{
public:
# 616 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline rtx jump_label () const;
inline rtx_code_label *jump_target () const;
inline void set_jump_target (rtx_code_label *);
};
struct rtx_call_insn : public rtx_insn
{
# 638 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
};
struct rtx_jump_table_data : public rtx_insn
{
# 662 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline rtvec get_labels () const;
inline scalar_int_mode get_data_mode () const;
};
struct rtx_barrier : public rtx_insn
{
};
struct rtx_code_label : public rtx_insn
{
};
struct rtx_note : public rtx_insn
{
};
# 735 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
struct rtvec_def {
int num_elem;
rtx elem[1];
};
# 877 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
template <>
template <>
inline bool
is_a_helper <rtx_insn *>::test (rtx rt)
{
return ((((((enum rtx_code) (rt)->code) == INSN) || (((enum rtx_code) (rt)->code) == JUMP_INSN) || (((enum rtx_code) (rt)->code) == CALL_INSN)) || (((enum rtx_code) (rt)->code) == DEBUG_INSN))
|| (((enum rtx_code) (rt)->code) == NOTE)
|| (((enum rtx_code) (rt)->code) == JUMP_TABLE_DATA)
|| (((enum rtx_code) (rt)->code) == BARRIER)
|| (((enum rtx_code) (rt)->code) == CODE_LABEL));
}
template <>
template <>
inline bool
is_a_helper <const rtx_insn *>::test (const_rtx rt)
{
return ((((((enum rtx_code) (rt)->code) == INSN) || (((enum rtx_code) (rt)->code) == JUMP_INSN) || (((enum rtx_code) (rt)->code) == CALL_INSN)) || (((enum rtx_code) (rt)->code) == DEBUG_INSN))
|| (((enum rtx_code) (rt)->code) == NOTE)
|| (((enum rtx_code) (rt)->code) == JUMP_TABLE_DATA)
|| (((enum rtx_code) (rt)->code) == BARRIER)
|| (((enum rtx_code) (rt)->code) == CODE_LABEL));
}
template <>
template <>
inline bool
is_a_helper <rtx_debug_insn *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == DEBUG_INSN);
}
template <>
template <>
inline bool
is_a_helper <rtx_nonjump_insn *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == INSN);
}
template <>
template <>
inline bool
is_a_helper <rtx_jump_insn *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == JUMP_INSN);
}
template <>
template <>
inline bool
is_a_helper <rtx_jump_insn *>::test (rtx_insn *insn)
{
return (((enum rtx_code) (insn)->code) == JUMP_INSN);
}
template <>
template <>
inline bool
is_a_helper <rtx_call_insn *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == CALL_INSN);
}
template <>
template <>
inline bool
is_a_helper <rtx_call_insn *>::test (rtx_insn *insn)
{
return (((enum rtx_code) (insn)->code) == CALL_INSN);
}
template <>
template <>
inline bool
is_a_helper <rtx_jump_table_data *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == JUMP_TABLE_DATA);
}
template <>
template <>
inline bool
is_a_helper <rtx_jump_table_data *>::test (rtx_insn *insn)
{
return (((enum rtx_code) (insn)->code) == JUMP_TABLE_DATA);
}
template <>
template <>
inline bool
is_a_helper <rtx_barrier *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == BARRIER);
}
template <>
template <>
inline bool
is_a_helper <rtx_code_label *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == CODE_LABEL);
}
template <>
template <>
inline bool
is_a_helper <rtx_code_label *>::test (rtx_insn *insn)
{
return (((enum rtx_code) (insn)->code) == CODE_LABEL);
}
template <>
template <>
inline bool
is_a_helper <rtx_note *>::test (rtx rt)
{
return (((enum rtx_code) (rt)->code) == NOTE);
}
template <>
template <>
inline bool
is_a_helper <rtx_note *>::test (rtx_insn *insn)
{
return (((enum rtx_code) (insn)->code) == NOTE);
}
# 1321 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern void rtl_check_failed_flag (const char *, const_rtx, const char *,
int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__))
;
# 1392 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline rtx_expr_list *rtx_expr_list::next () const
{
rtx tmp = (((this)->u.fld[1]).rt_rtx);
return safe_as_a <rtx_expr_list *> (tmp);
}
inline rtx rtx_expr_list::element () const
{
return (((this)->u.fld[0]).rt_rtx);
}
inline rtx_insn_list *rtx_insn_list::next () const
{
rtx tmp = (((this)->u.fld[1]).rt_rtx);
return safe_as_a <rtx_insn_list *> (tmp);
}
inline rtx_insn *rtx_insn_list::insn () const
{
rtx tmp = (((this)->u.fld[0]).rt_rtx);
return safe_as_a <rtx_insn *> (tmp);
}
inline int rtx_sequence::len () const
{
return (((((this)->u.fld[0]).rt_rtvec))->num_elem);
}
inline rtx rtx_sequence::element (int index) const
{
return (((((this)->u.fld[0]).rt_rtvec))->elem[index]);
}
inline rtx_insn *rtx_sequence::insn (int index) const
{
return as_a <rtx_insn *> ((((((this)->u.fld[0]).rt_rtvec))->elem[index]));
}
inline int INSN_UID (const_rtx insn)
{
return __extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if (!((unsigned long) (((enum rtx_code) (_rtx)->code)) - (unsigned long) (DEBUG_INSN) <= (unsigned long) (NOTE) - (unsigned long) (DEBUG_INSN))) rtl_check_failed_flag ("INSN_UID", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 1440, __FUNCTION__); _rtx; })
->u2.insn_uid;
}
inline int& INSN_UID (rtx insn)
{
return __extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if (!((unsigned long) (((enum rtx_code) (_rtx)->code)) - (unsigned long) (DEBUG_INSN) <= (unsigned long) (NOTE) - (unsigned long) (DEBUG_INSN))) rtl_check_failed_flag ("INSN_UID", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 1445, __FUNCTION__); _rtx; })
->u2.insn_uid;
}
# 1456 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline rtx_insn *PREV_INSN (const rtx_insn *insn)
{
rtx prev = (((insn)->u.fld[0]).rt_rtx);
return safe_as_a <rtx_insn *> (prev);
}
inline rtx& SET_PREV_INSN (rtx_insn *insn)
{
return (((insn)->u.fld[0]).rt_rtx);
}
inline rtx_insn *NEXT_INSN (const rtx_insn *insn)
{
rtx next = (((insn)->u.fld[1]).rt_rtx);
return safe_as_a <rtx_insn *> (next);
}
inline rtx& SET_NEXT_INSN (rtx_insn *insn)
{
return (((insn)->u.fld[1]).rt_rtx);
}
inline basic_block BLOCK_FOR_INSN (const_rtx insn)
{
return (((insn)->u.fld[2]).rt_bb);
}
inline basic_block& BLOCK_FOR_INSN (rtx insn)
{
return (((insn)->u.fld[2]).rt_bb);
}
inline void set_block_for_insn (rtx_insn *insn, basic_block bb)
{
BLOCK_FOR_INSN (insn) = bb;
}
inline rtx PATTERN (const_rtx insn)
{
return (((insn)->u.fld[3]).rt_rtx);
}
inline rtx& PATTERN (rtx insn)
{
return (((insn)->u.fld[3]).rt_rtx);
}
inline unsigned int INSN_LOCATION (const rtx_insn *insn)
{
return (((insn)->u.fld[4]).rt_uint);
}
inline unsigned int& INSN_LOCATION (rtx_insn *insn)
{
return (((insn)->u.fld[4]).rt_uint);
}
inline bool INSN_HAS_LOCATION (const rtx_insn *insn)
{
return ((IS_ADHOC_LOC (INSN_LOCATION (insn))) ? get_location_from_adhoc_loc (line_table, INSN_LOCATION (insn)) : (INSN_LOCATION (insn))) != ((location_t) 0);
}
# 1528 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline rtvec rtx_jump_table_data::get_labels () const
{
rtx pat = PATTERN (this);
if (((enum rtx_code) (pat)->code) == ADDR_VEC)
return (((pat)->u.fld[0]).rt_rtvec);
else
return (((pat)->u.fld[1]).rt_rtvec);
}
inline scalar_int_mode
rtx_jump_table_data::get_data_mode () const
{
return as_a <scalar_int_mode> (((machine_mode) (PATTERN (this))->mode));
}
inline rtx_jump_table_data *
jump_table_for_label (const rtx_code_label *label)
{
return safe_dyn_cast <rtx_jump_table_data *> (NEXT_INSN (label));
}
# 1617 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum reg_note
{
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/reg-notes.def" 1
# 38 "/home/giulianob/gcc_git_gnu/gcc/gcc/reg-notes.def"
REG_DEP_TRUE,
REG_DEAD,
REG_INC,
# 57 "/home/giulianob/gcc_git_gnu/gcc/gcc/reg-notes.def"
REG_EQUIV,
REG_EQUAL,
REG_NONNEG,
REG_UNUSED,
# 81 "/home/giulianob/gcc_git_gnu/gcc/gcc/reg-notes.def"
REG_CC_SETTER,
REG_CC_USER,
REG_LABEL_TARGET,
REG_LABEL_OPERAND,
REG_DEP_OUTPUT,
REG_DEP_ANTI,
REG_DEP_CONTROL,
REG_BR_PROB,
REG_NOALIAS,
REG_BR_PRED,
REG_FRAME_RELATED_EXPR,
# 132 "/home/giulianob/gcc_git_gnu/gcc/gcc/reg-notes.def"
REG_CFA_DEF_CFA,
REG_CFA_ADJUST_CFA,
REG_CFA_OFFSET,
REG_CFA_REGISTER,
REG_CFA_EXPRESSION,
REG_CFA_VAL_EXPRESSION,
REG_CFA_RESTORE,
REG_CFA_SET_VDRAP,
REG_CFA_WINDOW_SAVE,
REG_CFA_FLUSH_QUEUE,
REG_CFA_TOGGLE_RA_MANGLE,
REG_EH_REGION,
REG_SAVE_NOTE,
REG_NORETURN,
REG_NON_LOCAL_GOTO,
REG_SETJMP,
REG_TM,
REG_ARGS_SIZE,
REG_RETURNED,
REG_STACK_CHECK,
REG_CALL_DECL,
REG_CALL_NOCF_CHECK,
REG_CALL_ARG_LOCATION,
# 1621 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 2
REG_NOTE_MAX
};
# 1632 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern const char * const reg_note_name[];
# 1784 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum insn_note
{
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/insn-notes.def" 1
# 35 "/home/giulianob/gcc_git_gnu/gcc/gcc/insn-notes.def"
NOTE_INSN_DELETED,
NOTE_INSN_DELETED_LABEL,
NOTE_INSN_DELETED_DEBUG_LABEL,
NOTE_INSN_BLOCK_BEG,
NOTE_INSN_BLOCK_END,
NOTE_INSN_FUNCTION_BEG,
NOTE_INSN_PROLOGUE_END,
NOTE_INSN_EPILOGUE_BEG,
NOTE_INSN_EH_REGION_BEG,
NOTE_INSN_EH_REGION_END,
NOTE_INSN_VAR_LOCATION,
NOTE_INSN_BEGIN_STMT,
NOTE_INSN_INLINE_ENTRY,
NOTE_INSN_BASIC_BLOCK,
NOTE_INSN_SWITCH_TEXT_SECTIONS,
NOTE_INSN_CFI,
NOTE_INSN_CFI_LABEL,
NOTE_INSN_UPDATE_SJLJ_CONTEXT,
# 1788 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 2
NOTE_INSN_MAX
};
extern const char * const note_insn_name[NOTE_INSN_MAX];
# 1810 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum label_kind
{
LABEL_NORMAL = 0,
LABEL_STATIC_ENTRY,
LABEL_GLOBAL_ENTRY,
LABEL_WEAK_ENTRY
};
# 1862 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline rtx_insn *JUMP_LABEL_AS_INSN (const rtx_insn *insn)
{
return safe_as_a <rtx_insn *> ((((insn)->u.fld[7]).rt_rtx));
}
inline rtx rtx_jump_insn::jump_label () const
{
return (((this)->u.fld[7]).rt_rtx);
}
inline rtx_code_label *rtx_jump_insn::jump_target () const
{
return safe_as_a <rtx_code_label *> ((((this)->u.fld[7]).rt_rtx));
}
inline void rtx_jump_insn::set_jump_target (rtx_code_label *target)
{
(((this)->u.fld[7]).rt_rtx) = target;
}
static inline rtx_insn *
label_ref_label (const_rtx ref)
{
return as_a<rtx_insn *> ((((ref)->u.fld[0]).rt_rtx));
}
static inline void
set_label_ref_label (rtx ref, rtx_insn *label)
{
(((ref)->u.fld[0]).rt_rtx) = label;
}
# 1921 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
static inline unsigned int
rhs_regno (const_rtx x)
{
return (&(x)->u.reg)->regno;
}
static inline unsigned int
END_REGNO (const_rtx x)
{
return (rhs_regno(x)) + ((&(x)->u.reg)->nregs);
}
static inline void
set_regno_raw (rtx x, unsigned int regno, unsigned int nregs)
{
reg_info *reg = (&(x)->u.reg);
reg->regno = regno;
reg->nregs = nregs;
}
# 2026 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline unsigned int
const_vector_encoded_nelts (const_rtx x)
{
return (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_VECTOR) rtl_check_failed_flag ("CONST_VECTOR_NPATTERNS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2029, __FUNCTION__); _rtx; }) ->u2.const_vector.npatterns) * (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_VECTOR) rtl_check_failed_flag ("CONST_VECTOR_NELTS_PER_PATTERN", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2029, __FUNCTION__); _rtx; }) ->u2.const_vector.nelts_per_pattern);
}
# 2053 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
static inline bool
always_void_p (enum rtx_code code)
{
return code == SET;
}
struct full_rtx_costs
{
int speed;
int size;
};
static inline void
init_costs_to_max (struct full_rtx_costs *c)
{
c->speed = 0x7fffffff;
c->size = 0x7fffffff;
}
static inline void
init_costs_to_zero (struct full_rtx_costs *c)
{
c->speed = 0;
c->size = 0;
}
static inline bool
costs_lt_p (struct full_rtx_costs *a, struct full_rtx_costs *b,
bool speed)
{
if (speed)
return (a->speed < b->speed
|| (a->speed == b->speed && a->size < b->size));
else
return (a->size < b->size
|| (a->size == b->size && a->speed < b->speed));
}
static inline void
costs_add_n_insns (struct full_rtx_costs *c, int n)
{
c->speed += ((n) * 4);
c->size += ((n) * 4);
}
class subreg_shape {
public:
subreg_shape (machine_mode, poly_uint16, machine_mode);
bool operator == (const subreg_shape &) const;
bool operator != (const subreg_shape &) const;
unsigned long unique_id () const;
machine_mode inner_mode;
poly_uint16 offset;
machine_mode outer_mode;
};
inline
subreg_shape::subreg_shape (machine_mode inner_mode_in,
poly_uint16 offset_in,
machine_mode outer_mode_in)
: inner_mode (inner_mode_in), offset (offset_in), outer_mode (outer_mode_in)
{}
inline bool
subreg_shape::operator == (const subreg_shape &other) const
{
return (inner_mode == other.inner_mode
&& (!maybe_ne (offset, other.offset))
&& outer_mode == other.outer_mode);
}
inline bool
subreg_shape::operator != (const subreg_shape &other) const
{
return !operator == (other);
}
inline unsigned long
subreg_shape::unique_id () const
{
{ static_assert ((MAX_MACHINE_MODE <= 256), "MAX_MACHINE_MODE <= 256"); }
{ static_assert ((1 <= 3), "NUM_POLY_INT_COEFFS <= 3"); }
{ static_assert ((sizeof (offset.coeffs[0]) <= 2), "sizeof (offset.coeffs[0]) <= 2"); }
int res = (int) inner_mode + ((int) outer_mode << 8);
for (int i = 0; i < 1; ++i)
res += (long) offset.coeffs[i] << ((1 + i) * 16);
return res;
}
static inline subreg_shape
shape_of_subreg (const_rtx x)
{
return subreg_shape (((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode),
(((x)->u.fld[1]).rt_subreg), ((machine_mode) (x)->mode));
}
struct address_info {
machine_mode mode;
addr_space_t as;
bool autoinc_p;
rtx *outer;
# 2199 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
rtx *inner;
# 2219 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
rtx *segment;
rtx *base;
rtx *index;
rtx *disp;
rtx *segment_term;
rtx *base_term;
rtx *index_term;
rtx *disp_term;
rtx *base_term2;
enum rtx_code addr_outer_code;
enum rtx_code base_outer_code;
};
typedef std::pair <rtx, machine_mode> rtx_mode_t;
namespace wi
{
template <>
struct int_traits <rtx_mode_t>
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = false;
static unsigned int get_precision (const rtx_mode_t &);
static wi::storage_ref decompose (long *, unsigned int,
const rtx_mode_t &);
};
}
inline unsigned int
wi::int_traits <rtx_mode_t>::get_precision (const rtx_mode_t &x)
{
return GET_MODE_PRECISION (as_a <scalar_mode> (x.second));
}
inline wi::storage_ref
wi::int_traits <rtx_mode_t>::decompose (long *,
unsigned int precision,
const rtx_mode_t &x)
{
((void)(!(precision == get_precision (x)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2273, __FUNCTION__), 0 : 0));
switch (((enum rtx_code) (x.first)->code))
{
case CONST_INT:
if (precision < 64)
((void)(!(((x.first)->u.hwint[0]) == sext_hwi (((x.first)->u.hwint[0]), precision) || (x.second == (scalar_int_mode ((scalar_int_mode::from_int) E_BImode)) && ((x.first)->u.hwint[0]) == 1)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2280, __FUNCTION__), 0 : 0))
;
return wi::storage_ref (&((x.first)->u.hwint[0]), 1, precision);
case CONST_WIDE_INT:
return wi::storage_ref (&((x.first)->u.hwiv.elem[0]),
((int)__extension__ ({ __typeof ((x.first)) const _rtx = ((x.first)); if (((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag ("CWI_GET_NUM_ELEM", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2288, __FUNCTION__); _rtx; })->u2.num_elem), precision);
default:
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2296, __FUNCTION__));
}
}
namespace wi
{
hwi_with_prec shwi (long, machine_mode mode);
wide_int min_value (machine_mode, signop);
wide_int max_value (machine_mode, signop);
}
inline wi::hwi_with_prec
wi::shwi (long val, machine_mode mode)
{
return shwi (val, GET_MODE_PRECISION (as_a <scalar_mode> (mode)));
}
inline wide_int
wi::min_value (machine_mode mode, signop sgn)
{
return min_value (GET_MODE_PRECISION (as_a <scalar_mode> (mode)), sgn);
}
inline wide_int
wi::max_value (machine_mode mode, signop sgn)
{
return max_value (GET_MODE_PRECISION (as_a <scalar_mode> (mode)), sgn);
}
namespace wi
{
typedef poly_int<1,
generic_wide_int <wide_int_ref_storage <false, false> > >
rtx_to_poly_wide_ref;
rtx_to_poly_wide_ref to_poly_wide (const_rtx, machine_mode);
}
inline wi::rtx_to_poly_wide_ref
const_poly_int_value (const_rtx x)
{
poly_int<1, generic_wide_int <wide_int_ref_storage <wi::int_traits <wide_int>::is_sign_extended, wi::int_traits <wide_int>::host_dependent_precision> > > res;
for (unsigned int i = 0; i < 1; ++i)
res.coeffs[i] = (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_POLY_INT) rtl_check_failed_flag ("CONST_POLY_INT_COEFFS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2344, __FUNCTION__); _rtx; })->u.cpi.coeffs)[i];
return res;
}
inline bool
poly_int_rtx_p (const_rtx x)
{
return ((((enum rtx_code) (x)->code) == CONST_INT) || (((enum rtx_code) (x)->code) == CONST_WIDE_INT)) || (1 > 1 && ((enum rtx_code) (x)->code) == CONST_POLY_INT);
}
inline wi::rtx_to_poly_wide_ref
wi::to_poly_wide (const_rtx x, machine_mode mode)
{
if ((1 > 1 && ((enum rtx_code) (x)->code) == CONST_POLY_INT))
return const_poly_int_value (x);
return rtx_mode_t (const_cast<rtx> (x), mode);
}
inline poly_int64
rtx_to_poly_int64 (const_rtx x)
{
if ((1 > 1 && ((enum rtx_code) (x)->code) == CONST_POLY_INT))
{
poly_int64 res;
for (unsigned int i = 0; i < 1; ++i)
res.coeffs[i] = (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_POLY_INT) rtl_check_failed_flag ("CONST_POLY_INT_COEFFS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2377, __FUNCTION__); _rtx; })->u.cpi.coeffs)[i].to_shwi ();
return res;
}
return ((x)->u.hwint[0]);
}
inline bool
poly_int_rtx_p (const_rtx x, poly_int64_pod *res)
{
if ((((enum rtx_code) (x)->code) == CONST_INT))
{
*res = ((x)->u.hwint[0]);
return true;
}
if ((1 > 1 && ((enum rtx_code) (x)->code) == CONST_POLY_INT))
{
for (unsigned int i = 0; i < 1; ++i)
if (!wi::fits_shwi_p ((__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_POLY_INT) rtl_check_failed_flag ("CONST_POLY_INT_COEFFS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2398, __FUNCTION__); _rtx; })->u.cpi.coeffs)[i]))
return false;
for (unsigned int i = 0; i < 1; ++i)
res->coeffs[i] = (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_POLY_INT) rtl_check_failed_flag ("CONST_POLY_INT_COEFFS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 2401, __FUNCTION__); _rtx; })->u.cpi.coeffs)[i].to_shwi ();
return true;
}
return false;
}
extern void init_rtlanal (void);
extern int rtx_cost (rtx, machine_mode, enum rtx_code, int, bool);
extern int address_cost (rtx, machine_mode, addr_space_t, bool);
extern void get_full_rtx_cost (rtx, machine_mode, enum rtx_code, int,
struct full_rtx_costs *);
extern bool native_encode_rtx (machine_mode, rtx, vec<target_unit> &,
unsigned int, unsigned int);
extern rtx native_decode_rtx (machine_mode, vec<target_unit>,
unsigned int);
extern rtx native_decode_vector_rtx (machine_mode, vec<target_unit>,
unsigned int, unsigned int, unsigned int);
extern poly_uint64 subreg_lsb (const_rtx);
extern poly_uint64 subreg_size_lsb (poly_uint64, poly_uint64, poly_uint64);
extern poly_uint64 subreg_size_offset_from_lsb (poly_uint64, poly_uint64,
poly_uint64);
extern bool read_modify_subreg_p (const_rtx);
inline poly_uint64
subreg_lsb_1 (machine_mode outer_mode, machine_mode inner_mode,
poly_uint64 subreg_byte)
{
return subreg_size_lsb (GET_MODE_SIZE (outer_mode),
GET_MODE_SIZE (inner_mode), subreg_byte);
}
inline poly_uint64
subreg_offset_from_lsb (machine_mode outer_mode,
machine_mode inner_mode,
poly_uint64 lsb_shift)
{
return subreg_size_offset_from_lsb (GET_MODE_SIZE (outer_mode),
GET_MODE_SIZE (inner_mode), lsb_shift);
}
extern unsigned int subreg_regno_offset (unsigned int, machine_mode,
poly_uint64, machine_mode);
extern bool subreg_offset_representable_p (unsigned int, machine_mode,
poly_uint64, machine_mode);
extern unsigned int subreg_regno (const_rtx);
extern int simplify_subreg_regno (unsigned int, machine_mode,
poly_uint64, machine_mode);
extern unsigned int subreg_nregs (const_rtx);
extern unsigned int subreg_nregs_with_regno (unsigned int, const_rtx);
extern unsigned long nonzero_bits (const_rtx, machine_mode);
extern unsigned int num_sign_bit_copies (const_rtx, machine_mode);
extern bool constant_pool_constant_p (rtx);
extern bool truncated_to_mode (machine_mode, const_rtx);
extern int low_bitmask_len (machine_mode, unsigned long);
extern void split_double (rtx, rtx *, rtx *);
extern rtx *strip_address_mutations (rtx *, enum rtx_code * = 0);
extern void decompose_address (struct address_info *, rtx *,
machine_mode, addr_space_t, enum rtx_code);
extern void decompose_lea_address (struct address_info *, rtx *);
extern void decompose_mem_address (struct address_info *, rtx);
extern void update_address (struct address_info *);
extern long get_index_scale (const struct address_info *);
extern enum rtx_code get_index_code (const struct address_info *);
# 2497 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
const int SRP_POINTER = -1;
const int SRP_SIGNED = 0;
const int SRP_UNSIGNED = 1;
const int SRP_SIGNED_AND_UNSIGNED = 2;
# 2901 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern int generating_concat_p;
extern int currently_expanding_to_rtl;
static inline int
set_rtx_cost (rtx x, bool speed_p)
{
return rtx_cost (x, ((void) 0, E_VOIDmode), INSN, 4, speed_p);
}
static inline void
get_full_set_rtx_cost (rtx x, struct full_rtx_costs *c)
{
get_full_rtx_cost (x, ((void) 0, E_VOIDmode), INSN, 4, c);
}
static inline int
set_src_cost (rtx x, machine_mode mode, bool speed_p)
{
return rtx_cost (x, mode, SET, 1, speed_p);
}
static inline void
get_full_set_src_cost (rtx x, machine_mode mode, struct full_rtx_costs *c)
{
get_full_rtx_cost (x, mode, SET, 1, c);
}
# 2956 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern long trunc_int_for_mode (long, machine_mode);
extern poly_int64 trunc_int_for_mode (poly_int64, machine_mode);
extern rtx plus_constant (machine_mode, rtx, poly_int64, bool = false);
extern long get_stack_check_protect (void);
extern rtx rtx_alloc (enum rtx_code );
inline rtx
rtx_init (rtx rt, enum rtx_code code)
{
memset (rt, 0,
# 2966 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 3 4
__builtin_offsetof (
# 2966 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
struct rtx_def
# 2966 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 3 4
,
# 2966 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
u
# 2966 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 3 4
)
# 2966 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
);
((rt)->code = (code));
return rt;
}
extern rtx rtx_alloc_stat_v (enum rtx_code , int);
extern rtvec rtvec_alloc (int);
extern rtvec shallow_copy_rtvec (rtvec);
extern bool shared_const_p (const_rtx);
extern rtx copy_rtx (rtx);
extern enum rtx_code classify_insn (rtx);
extern void dump_rtx_statistics (void);
extern rtx copy_rtx_if_shared (rtx);
extern unsigned int rtx_size (const_rtx);
extern rtx shallow_copy_rtx (const_rtx );
extern int rtx_equal_p (const_rtx, const_rtx);
extern bool rtvec_all_equal_p (const_rtvec);
inline bool
const_vec_duplicate_p (const_rtx x)
{
return (((enum rtx_code) (x)->code) == CONST_VECTOR
&& (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_VECTOR) rtl_check_failed_flag ("CONST_VECTOR_NPATTERNS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3001, __FUNCTION__); _rtx; }) ->u2.const_vector.npatterns) == 1
&& ((__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_VECTOR) rtl_check_failed_flag ("CONST_VECTOR_NELTS_PER_PATTERN", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3002, __FUNCTION__); _rtx; }) ->u2.const_vector.nelts_per_pattern) == 1));
}
template <typename T>
inline bool
const_vec_duplicate_p (T x, T *elt)
{
if (const_vec_duplicate_p (x))
{
*elt = (((((x)->u.fld[0]).rt_rtvec))->elem[0]);
return true;
}
return false;
}
template <typename T>
inline bool
vec_duplicate_p (T x, T *elt)
{
if (((enum rtx_code) (x)->code) == VEC_DUPLICATE
&& !(((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_BOOL || ((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_INT || ((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_FLOAT || ((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_FRACT || ((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_UFRACT || ((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_ACCUM || ((enum mode_class) mode_class[((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode)]) == MODE_VECTOR_UACCUM))
{
*elt = (((x)->u.fld[0]).rt_rtx);
return true;
}
return const_vec_duplicate_p (x, elt);
}
template <typename T>
inline T
unwrap_const_vec_duplicate (T x)
{
if (const_vec_duplicate_p (x))
x = const_vector_elt (x, 0);
return x;
}
extern wide_int const_vector_int_elt (const_rtx, unsigned int);
extern rtx const_vector_elt (const_rtx, unsigned int);
extern bool const_vec_series_p_1 (const_rtx, rtx *, rtx *);
# 3060 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline bool
const_vec_series_p (const_rtx x, rtx *base_out, rtx *step_out)
{
if (((enum rtx_code) (x)->code) == CONST_VECTOR
&& (__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_VECTOR) rtl_check_failed_flag ("CONST_VECTOR_NPATTERNS", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3064, __FUNCTION__); _rtx; }) ->u2.const_vector.npatterns) == 1
&& !((__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != CONST_VECTOR) rtl_check_failed_flag ("CONST_VECTOR_NELTS_PER_PATTERN", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3065, __FUNCTION__); _rtx; }) ->u2.const_vector.nelts_per_pattern) == 1))
return const_vec_series_p_1 (x, base_out, step_out);
return false;
}
# 3078 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline bool
vec_series_p (const_rtx x, rtx *base_out, rtx *step_out)
{
if (((enum rtx_code) (x)->code) == VEC_SERIES)
{
*base_out = (((x)->u.fld[0]).rt_rtx);
*step_out = (((x)->u.fld[1]).rt_rtx);
return true;
}
return const_vec_series_p (x, base_out, step_out);
}
inline scalar_int_mode
subreg_unpromoted_mode (rtx x)
{
((void)(!((__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != SUBREG) rtl_check_failed_flag ("SUBREG_PROMOTED", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3095, __FUNCTION__); _rtx; })->in_struct)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3095, __FUNCTION__), 0 : 0));
return as_a <scalar_int_mode> (((machine_mode) (x)->mode));
}
inline scalar_int_mode
subreg_promoted_mode (rtx x)
{
((void)(!((__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum rtx_code) (_rtx)->code) != SUBREG) rtl_check_failed_flag ("SUBREG_PROMOTED", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3104, __FUNCTION__); _rtx; })->in_struct)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3104, __FUNCTION__), 0 : 0));
return as_a <scalar_int_mode> (((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode));
}
extern rtvec gen_rtvec_v (int, rtx *);
extern rtvec gen_rtvec_v (int, rtx_insn **);
extern rtx gen_reg_rtx (machine_mode);
extern rtx gen_rtx_REG_offset (rtx, machine_mode, unsigned int, poly_int64);
extern rtx gen_reg_rtx_offset (rtx, machine_mode, int);
extern rtx gen_reg_rtx_and_attrs (rtx);
extern rtx_code_label *gen_label_rtx (void);
extern rtx gen_lowpart_common (machine_mode, rtx);
extern rtx gen_lowpart_if_possible (machine_mode, rtx);
extern rtx gen_highpart (machine_mode, rtx);
extern rtx gen_highpart_mode (machine_mode, machine_mode, rtx);
extern rtx operand_subword (rtx, poly_uint64, int, machine_mode);
extern rtx operand_subword_force (rtx, poly_uint64, machine_mode);
extern int subreg_lowpart_p (const_rtx);
extern poly_uint64 subreg_size_lowpart_offset (poly_uint64, poly_uint64);
inline bool
partial_subreg_p (machine_mode outermode, machine_mode innermode)
{
poly_int64 outer_prec = GET_MODE_PRECISION (outermode);
poly_int64 inner_prec = GET_MODE_PRECISION (innermode);
((void)(!(ordered_p (outer_prec, inner_prec)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3144, __FUNCTION__), 0 : 0));
return maybe_lt (outer_prec, inner_prec);
}
inline bool
partial_subreg_p (const_rtx x)
{
if (((enum rtx_code) (x)->code) != SUBREG)
return false;
return partial_subreg_p (((machine_mode) (x)->mode), ((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode));
}
inline bool
paradoxical_subreg_p (machine_mode outermode, machine_mode innermode)
{
poly_int64 outer_prec = GET_MODE_PRECISION (outermode);
poly_int64 inner_prec = GET_MODE_PRECISION (innermode);
((void)(!(ordered_p (outer_prec, inner_prec)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h", 3170, __FUNCTION__), 0 : 0));
return maybe_lt (inner_prec, outer_prec);
}
inline bool
paradoxical_subreg_p (const_rtx x)
{
if (((enum rtx_code) (x)->code) != SUBREG)
return false;
return paradoxical_subreg_p (((machine_mode) (x)->mode), ((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode));
}
inline poly_uint64
subreg_lowpart_offset (machine_mode outermode, machine_mode innermode)
{
return subreg_size_lowpart_offset (GET_MODE_SIZE (outermode),
GET_MODE_SIZE (innermode));
}
inline machine_mode
narrower_subreg_mode (machine_mode outermode, machine_mode innermode)
{
return paradoxical_subreg_p (outermode, innermode) ? innermode : outermode;
}
inline machine_mode
wider_subreg_mode (machine_mode outermode, machine_mode innermode)
{
return partial_subreg_p (outermode, innermode) ? innermode : outermode;
}
inline machine_mode
wider_subreg_mode (const_rtx x)
{
return wider_subreg_mode (((machine_mode) (x)->mode), ((machine_mode) ((((x)->u.fld[0]).rt_rtx))->mode));
}
extern poly_uint64 subreg_size_highpart_offset (poly_uint64, poly_uint64);
inline poly_uint64
subreg_highpart_offset (machine_mode outermode, machine_mode innermode)
{
return subreg_size_highpart_offset (GET_MODE_SIZE (outermode),
GET_MODE_SIZE (innermode));
}
extern poly_int64 byte_lowpart_offset (machine_mode, machine_mode);
extern poly_int64 subreg_memory_offset (machine_mode, machine_mode,
poly_uint64);
extern poly_int64 subreg_memory_offset (const_rtx);
extern rtx make_safe_from (rtx, rtx);
extern rtx convert_memory_address_addr_space_1 (scalar_int_mode, rtx,
addr_space_t, bool, bool);
extern rtx convert_memory_address_addr_space (scalar_int_mode, rtx,
addr_space_t);
extern const char *get_insn_name (int);
extern rtx_insn *get_last_insn_anywhere (void);
extern rtx_insn *get_first_nonnote_insn (void);
extern rtx_insn *get_last_nonnote_insn (void);
extern void start_sequence (void);
extern void push_to_sequence (rtx_insn *);
extern void push_to_sequence2 (rtx_insn *, rtx_insn *);
extern void end_sequence (void);
extern void cwi_output_hex (FILE *, const_rtx);
extern rtx immed_wide_int_const (const poly_wide_int_ref &, machine_mode);
extern rtx force_const_mem (machine_mode, rtx);
struct function;
extern rtx get_pool_constant (const_rtx);
extern rtx get_pool_constant_mark (rtx, bool *);
extern fixed_size_mode get_pool_mode (const_rtx);
extern rtx simplify_subtraction (rtx);
extern void decide_function_section (tree);
extern rtx_insn *emit_insn_before (rtx, rtx_insn *);
extern rtx_insn *emit_insn_before_noloc (rtx, rtx_insn *, basic_block);
extern rtx_insn *emit_insn_before_setloc (rtx, rtx_insn *, location_t);
extern rtx_jump_insn *emit_jump_insn_before (rtx, rtx_insn *);
extern rtx_jump_insn *emit_jump_insn_before_noloc (rtx, rtx_insn *);
extern rtx_jump_insn *emit_jump_insn_before_setloc (rtx, rtx_insn *,
location_t);
extern rtx_insn *emit_call_insn_before (rtx, rtx_insn *);
extern rtx_insn *emit_call_insn_before_noloc (rtx, rtx_insn *);
extern rtx_insn *emit_call_insn_before_setloc (rtx, rtx_insn *, location_t);
extern rtx_insn *emit_debug_insn_before (rtx, rtx_insn *);
extern rtx_insn *emit_debug_insn_before_noloc (rtx, rtx_insn *);
extern rtx_insn *emit_debug_insn_before_setloc (rtx, rtx_insn *, location_t);
extern rtx_barrier *emit_barrier_before (rtx_insn *);
extern rtx_code_label *emit_label_before (rtx_code_label *, rtx_insn *);
extern rtx_note *emit_note_before (enum insn_note, rtx_insn *);
extern rtx_insn *emit_insn_after (rtx, rtx_insn *);
extern rtx_insn *emit_insn_after_noloc (rtx, rtx_insn *, basic_block);
extern rtx_insn *emit_insn_after_setloc (rtx, rtx_insn *, location_t);
extern rtx_jump_insn *emit_jump_insn_after (rtx, rtx_insn *);
extern rtx_jump_insn *emit_jump_insn_after_noloc (rtx, rtx_insn *);
extern rtx_jump_insn *emit_jump_insn_after_setloc (rtx, rtx_insn *, location_t);
extern rtx_insn *emit_call_insn_after (rtx, rtx_insn *);
extern rtx_insn *emit_call_insn_after_noloc (rtx, rtx_insn *);
extern rtx_insn *emit_call_insn_after_setloc (rtx, rtx_insn *, location_t);
extern rtx_insn *emit_debug_insn_after (rtx, rtx_insn *);
extern rtx_insn *emit_debug_insn_after_noloc (rtx, rtx_insn *);
extern rtx_insn *emit_debug_insn_after_setloc (rtx, rtx_insn *, location_t);
extern rtx_barrier *emit_barrier_after (rtx_insn *);
extern rtx_insn *emit_label_after (rtx_insn *, rtx_insn *);
extern rtx_note *emit_note_after (enum insn_note, rtx_insn *);
extern rtx_insn *emit_insn (rtx);
extern rtx_insn *emit_debug_insn (rtx);
extern rtx_insn *emit_jump_insn (rtx);
extern rtx_insn *emit_call_insn (rtx);
extern rtx_code_label *emit_label (rtx);
extern rtx_jump_table_data *emit_jump_table_data (rtx);
extern rtx_barrier *emit_barrier (void);
extern rtx_note *emit_note (enum insn_note);
extern rtx_note *emit_note_copy (rtx_note *);
extern rtx_insn *gen_clobber (rtx);
extern rtx_insn *emit_clobber (rtx);
extern rtx_insn *gen_use (rtx);
extern rtx_insn *emit_use (rtx);
extern rtx_insn *make_insn_raw (rtx);
extern void add_function_usage_to (rtx, rtx);
extern rtx_call_insn *last_call_insn (void);
extern rtx_insn *previous_insn (rtx_insn *);
extern rtx_insn *next_insn (rtx_insn *);
extern rtx_insn *prev_nonnote_insn (rtx_insn *);
extern rtx_insn *next_nonnote_insn (rtx_insn *);
extern rtx_insn *prev_nondebug_insn (rtx_insn *);
extern rtx_insn *next_nondebug_insn (rtx_insn *);
extern rtx_insn *prev_nonnote_nondebug_insn (rtx_insn *);
extern rtx_insn *prev_nonnote_nondebug_insn_bb (rtx_insn *);
extern rtx_insn *next_nonnote_nondebug_insn (rtx_insn *);
extern rtx_insn *next_nonnote_nondebug_insn_bb (rtx_insn *);
extern rtx_insn *prev_real_insn (rtx_insn *);
extern rtx_insn *next_real_insn (rtx_insn *);
extern rtx_insn *prev_real_nondebug_insn (rtx_insn *);
extern rtx_insn *next_real_nondebug_insn (rtx);
extern rtx_insn *prev_active_insn (rtx_insn *);
extern rtx_insn *next_active_insn (rtx_insn *);
extern int active_insn_p (const rtx_insn *);
extern rtx_insn *next_cc0_user (rtx_insn *);
extern rtx_insn *prev_cc0_setter (rtx_insn *);
extern int insn_line (const rtx_insn *);
extern const char * insn_file (const rtx_insn *);
extern tree insn_scope (const rtx_insn *);
extern expanded_location insn_location (const rtx_insn *);
extern location_t prologue_location, epilogue_location;
extern enum rtx_code reverse_condition (enum rtx_code);
extern enum rtx_code reverse_condition_maybe_unordered (enum rtx_code);
extern enum rtx_code swap_condition (enum rtx_code);
extern enum rtx_code unsigned_condition (enum rtx_code);
extern enum rtx_code signed_condition (enum rtx_code);
extern void mark_jump_label (rtx, rtx_insn *, int);
inline bool
unsigned_condition_p (enum rtx_code code)
{
return unsigned_condition (code) == code;
}
extern rtx_insn *delete_related_insns (rtx);
extern rtx *find_constant_term_loc (rtx *);
extern rtx_insn *try_split (rtx, rtx_insn *, int);
extern rtx_insn *split_insns (rtx, rtx_insn *);
extern rtx simplify_const_unary_operation (enum rtx_code, machine_mode,
rtx, machine_mode);
extern rtx simplify_unary_operation (enum rtx_code, machine_mode, rtx,
machine_mode);
extern rtx simplify_const_binary_operation (enum rtx_code, machine_mode,
rtx, rtx);
extern rtx simplify_binary_operation (enum rtx_code, machine_mode, rtx,
rtx);
extern rtx simplify_ternary_operation (enum rtx_code, machine_mode,
machine_mode, rtx, rtx, rtx);
extern rtx simplify_const_relational_operation (enum rtx_code,
machine_mode, rtx, rtx);
extern rtx simplify_relational_operation (enum rtx_code, machine_mode,
machine_mode, rtx, rtx);
extern rtx simplify_gen_binary (enum rtx_code, machine_mode, rtx, rtx);
extern rtx simplify_gen_unary (enum rtx_code, machine_mode, rtx,
machine_mode);
extern rtx simplify_gen_ternary (enum rtx_code, machine_mode,
machine_mode, rtx, rtx, rtx);
extern rtx simplify_gen_relational (enum rtx_code, machine_mode,
machine_mode, rtx, rtx);
extern rtx simplify_subreg (machine_mode, rtx, machine_mode, poly_uint64);
extern rtx simplify_gen_subreg (machine_mode, rtx, machine_mode, poly_uint64);
extern rtx lowpart_subreg (machine_mode, rtx, machine_mode);
extern rtx simplify_replace_fn_rtx (rtx, const_rtx,
rtx (*fn) (rtx, const_rtx, void *), void *);
extern rtx simplify_replace_rtx (rtx, const_rtx, rtx);
extern rtx simplify_rtx (const_rtx);
extern rtx avoid_constant_pool_reference (rtx);
extern rtx delegitimize_mem_from_attrs (rtx);
extern bool mode_signbit_p (machine_mode, const_rtx);
extern bool val_signbit_p (machine_mode, unsigned long);
extern bool val_signbit_known_set_p (machine_mode,
unsigned long);
extern bool val_signbit_known_clear_p (machine_mode,
unsigned long);
extern machine_mode choose_hard_reg_mode (unsigned int, unsigned int,
const predefined_function_abi *);
extern const HARD_REG_SET &simplifiable_subregs (const subreg_shape &);
extern rtx set_for_reg_notes (rtx);
extern rtx set_unique_reg_note (rtx, enum reg_note, rtx);
extern rtx set_dst_reg_note (rtx, enum reg_note, rtx, rtx);
extern void set_insn_deleted (rtx_insn *);
extern rtx single_set_2 (const rtx_insn *, const_rtx);
extern bool contains_symbol_ref_p (const_rtx);
extern bool contains_symbolic_reference_p (const_rtx);
extern bool contains_constant_pool_address_p (const_rtx);
extern void add_auto_inc_notes (rtx_insn *, rtx);
inline rtx single_set (const rtx_insn *insn)
{
if (!(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) == DEBUG_INSN)))
return (rtx) 0;
if (((enum rtx_code) (PATTERN (insn))->code) == SET)
return PATTERN (insn);
return single_set_2 (insn, PATTERN (insn));
}
extern scalar_int_mode get_address_mode (rtx mem);
extern int rtx_addr_can_trap_p (const_rtx);
extern bool nonzero_address_p (const_rtx);
extern int rtx_unstable_p (const_rtx);
extern bool rtx_varies_p (const_rtx, bool);
extern bool rtx_addr_varies_p (const_rtx, bool);
extern rtx get_call_rtx_from (const rtx_insn *);
extern tree get_call_fndecl (const rtx_insn *);
extern long get_integer_term (const_rtx);
extern rtx get_related_value (const_rtx);
extern bool offset_within_block_p (const_rtx, long);
extern void split_const (rtx, rtx *, rtx *);
extern rtx strip_offset (rtx, poly_int64_pod *);
extern poly_int64 get_args_size (const_rtx);
extern bool unsigned_reg_p (rtx);
extern int reg_mentioned_p (const_rtx, const_rtx);
extern int count_occurrences (const_rtx, const_rtx, int);
extern int reg_referenced_p (const_rtx, const_rtx);
extern int reg_used_between_p (const_rtx, const rtx_insn *, const rtx_insn *);
extern int reg_set_between_p (const_rtx, const rtx_insn *, const rtx_insn *);
extern int commutative_operand_precedence (rtx);
extern bool swap_commutative_operands_p (rtx, rtx);
extern int modified_between_p (const_rtx, const rtx_insn *, const rtx_insn *);
extern int no_labels_between_p (const rtx_insn *, const rtx_insn *);
extern int modified_in_p (const_rtx, const_rtx);
extern int reg_set_p (const_rtx, const_rtx);
extern int multiple_sets (const_rtx);
extern int set_noop_p (const_rtx);
extern int noop_move_p (const rtx_insn *);
extern bool refers_to_regno_p (unsigned int, unsigned int, const_rtx, rtx *);
extern int reg_overlap_mentioned_p (const_rtx, const_rtx);
extern const_rtx set_of (const_rtx, const_rtx);
extern void record_hard_reg_sets (rtx, const_rtx, void *);
extern void record_hard_reg_uses (rtx *, void *);
extern void find_all_hard_regs (const_rtx, HARD_REG_SET *);
extern void find_all_hard_reg_sets (const rtx_insn *, HARD_REG_SET *, bool);
extern void note_pattern_stores (const_rtx,
void (*) (rtx, const_rtx, void *), void *);
extern void note_stores (const rtx_insn *,
void (*) (rtx, const_rtx, void *), void *);
extern void note_uses (rtx *, void (*) (rtx *, void *), void *);
extern int dead_or_set_p (const rtx_insn *, const_rtx);
extern int dead_or_set_regno_p (const rtx_insn *, unsigned int);
extern rtx find_reg_note (const_rtx, enum reg_note, const_rtx);
extern rtx find_regno_note (const_rtx, enum reg_note, unsigned int);
extern rtx find_reg_equal_equiv_note (const_rtx);
extern rtx find_constant_src (const rtx_insn *);
extern int find_reg_fusage (const_rtx, enum rtx_code, const_rtx);
extern int find_regno_fusage (const_rtx, enum rtx_code, unsigned int);
extern rtx alloc_reg_note (enum reg_note, rtx, rtx);
extern void add_reg_note (rtx, enum reg_note, rtx);
extern void add_int_reg_note (rtx_insn *, enum reg_note, int);
extern void add_args_size_note (rtx_insn *, poly_int64);
extern void add_shallow_copy_of_reg_note (rtx_insn *, rtx);
extern rtx duplicate_reg_note (rtx);
extern void remove_note (rtx_insn *, const_rtx);
extern bool remove_reg_equal_equiv_notes (rtx_insn *, bool = false);
extern void remove_reg_equal_equiv_notes_for_regno (unsigned int);
extern int side_effects_p (const_rtx);
extern int volatile_refs_p (const_rtx);
extern int volatile_insn_p (const_rtx);
extern int may_trap_p_1 (const_rtx, unsigned);
extern int may_trap_p (const_rtx);
extern int may_trap_or_fault_p (const_rtx);
extern bool can_throw_internal (const_rtx);
extern bool can_throw_external (const_rtx);
extern bool insn_could_throw_p (const_rtx);
extern bool insn_nothrow_p (const_rtx);
extern bool can_nonlocal_goto (const rtx_insn *);
extern void copy_reg_eh_region_note_forward (rtx, rtx_insn *, rtx);
extern void copy_reg_eh_region_note_backward (rtx, rtx_insn *, rtx);
extern rtx replace_rtx (rtx, rtx, rtx, bool = false);
extern void replace_label (rtx *, rtx, rtx, bool);
extern void replace_label_in_insn (rtx_insn *, rtx_insn *, rtx_insn *, bool);
extern bool rtx_referenced_p (const_rtx, const_rtx);
extern bool tablejump_p (const rtx_insn *, rtx_insn **, rtx_jump_table_data **);
extern rtx tablejump_casesi_pattern (const rtx_insn *insn);
extern int computed_jump_p (const rtx_insn *);
extern bool tls_referenced_p (const_rtx);
extern bool contains_mem_rtx_p (rtx x);
inline bool
refers_to_regno_p (unsigned int regnum, const_rtx x, rtx* loc = nullptr)
{
return refers_to_regno_p (regnum, regnum + 1, x, loc);
}
typedef int (*for_each_inc_dec_fn) (rtx mem, rtx op, rtx dest, rtx src,
rtx srcoff, void *arg);
extern int for_each_inc_dec (rtx, for_each_inc_dec_fn, void *arg);
typedef int (*rtx_equal_p_callback_function) (const_rtx *, const_rtx *,
rtx *, rtx *);
extern int rtx_equal_p_cb (const_rtx, const_rtx,
rtx_equal_p_callback_function);
typedef int (*hash_rtx_callback_function) (const_rtx, machine_mode, rtx *,
machine_mode *);
extern unsigned hash_rtx_cb (const_rtx, machine_mode, int *, int *,
bool, hash_rtx_callback_function);
extern rtx regno_use_in (unsigned int, rtx);
extern int auto_inc_p (const_rtx);
extern bool in_insn_list_p (const rtx_insn_list *, const rtx_insn *);
extern void remove_node_from_expr_list (const_rtx, rtx_expr_list **);
extern void remove_node_from_insn_list (const rtx_insn *, rtx_insn_list **);
extern int loc_mentioned_in_p (rtx *, const_rtx);
extern rtx_insn *find_first_parameter_load (rtx_insn *, rtx_insn *);
extern bool keep_with_call_p (const rtx_insn *);
extern bool label_is_jump_target_p (const_rtx, const rtx_insn *);
extern int pattern_cost (rtx, bool);
extern int insn_cost (rtx_insn *, bool);
extern unsigned seq_cost (const rtx_insn *, bool);
extern rtx canonicalize_condition (rtx_insn *, rtx, int, rtx_insn **, rtx,
int, int);
extern rtx get_condition (rtx_insn *, rtx_insn **, int, int);
struct subreg_info
{
int offset;
int nregs;
bool representable_p;
};
extern void subreg_get_info (unsigned int, machine_mode,
poly_uint64, machine_mode,
struct subreg_info *);
extern void free_EXPR_LIST_list (rtx_expr_list **);
extern void free_INSN_LIST_list (rtx_insn_list **);
extern void free_EXPR_LIST_node (rtx);
extern void free_INSN_LIST_node (rtx);
extern rtx_insn_list *alloc_INSN_LIST (rtx, rtx);
extern rtx_insn_list *copy_INSN_LIST (rtx_insn_list *);
extern rtx_insn_list *concat_INSN_LIST (rtx_insn_list *, rtx_insn_list *);
extern rtx_expr_list *alloc_EXPR_LIST (int, rtx, rtx);
extern void remove_free_INSN_LIST_elem (rtx_insn *, rtx_insn_list **);
extern rtx remove_list_elem (rtx, rtx *);
extern rtx_insn *remove_free_INSN_LIST_node (rtx_insn_list **);
extern rtx remove_free_EXPR_LIST_node (rtx_expr_list **);
extern bool resize_reg_info (void);
extern void free_reg_info (void);
extern void init_subregs_of_mode (void);
extern void finish_subregs_of_mode (void);
extern rtx extract_asm_operands (rtx);
extern int asm_noperands (const_rtx);
extern const char *decode_asm_operands (rtx, rtx *, rtx **, const char **,
machine_mode *, location_t *);
extern void get_referenced_operands (const char *, bool *, unsigned int);
extern enum reg_class reg_preferred_class (int);
extern enum reg_class reg_alternate_class (int);
extern enum reg_class reg_allocno_class (int);
extern void setup_reg_classes (int, enum reg_class, enum reg_class,
enum reg_class);
extern void split_all_insns (void);
extern unsigned int split_all_insns_noflow (void);
extern rtx const_int_rtx[64 * 2 + 1];
extern rtx const_true_rtx;
extern rtx const_tiny_rtx[4][(int) MAX_MACHINE_MODE];
# 3660 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern rtx pc_rtx;
extern rtx cc0_rtx;
extern rtx ret_rtx;
extern rtx simple_return_rtx;
extern rtx_insn *invalid_insn_rtx;
# 3687 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum global_rtl_index
{
GR_STACK_POINTER,
GR_FRAME_POINTER,
# 3700 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
GR_HARD_FRAME_POINTER,
GR_ARG_POINTER,
GR_VIRTUAL_INCOMING_ARGS,
GR_VIRTUAL_STACK_ARGS,
GR_VIRTUAL_STACK_DYNAMIC,
GR_VIRTUAL_OUTGOING_ARGS,
GR_VIRTUAL_CFA,
GR_VIRTUAL_PREFERRED_STACK_BOUNDARY,
GR_MAX
};
struct target_rtl {
# 3736 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
rtx x_global_rtl[GR_MAX];
rtx x_pic_offset_table_rtx;
rtx x_return_address_pointer_rtx;
rtx x_initial_regno_reg_rtx[76];
rtx x_top_of_stack[MAX_MACHINE_MODE];
rtx x_static_reg_base_value[76];
class mem_attrs *x_mode_mem_attrs[(int) MAX_MACHINE_MODE];
bool target_specific_initialized;
};
extern struct target_rtl default_target_rtl;
extern struct target_rtl *this_target_rtl;
# 3794 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
static inline const class mem_attrs *
get_mem_attrs (const_rtx x)
{
class mem_attrs *attrs;
attrs = (((x)->u.fld[1]).rt_mem);
if (!attrs)
attrs = (this_target_rtl->x_mode_mem_attrs)[(int) ((machine_mode) (x)->mode)];
return attrs;
}
# 1 "./genrtl.h" 1
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/statistics.h" 1
# 7 "./genrtl.h" 2
static inline rtx
init_rtx_fmt_0 (rtx rt, machine_mode mode)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_0_stat (enum rtx_code code, machine_mode mode )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_0 (rt, mode);
}
static inline rtx
init_rtx_fmt_ee (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_ee_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ee (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_ue (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_ue_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ue (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_ie (rtx rt, machine_mode mode,
int arg0,
rtx arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_int) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_ie_stat (enum rtx_code code, machine_mode mode,
int arg0,
rtx arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ie (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_E (rtx rt, machine_mode mode,
rtvec arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtvec) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_E_stat (enum rtx_code code, machine_mode mode,
rtvec arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_E (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_i (rtx rt, machine_mode mode,
int arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_int) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_i_stat (enum rtx_code code, machine_mode mode,
int arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_i (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_uuBeiie (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3,
int arg4,
int arg5,
rtx arg6)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_bb) = arg2;
(((rt)->u.fld[3]).rt_rtx) = arg3;
(((rt)->u.fld[4]).rt_int) = arg4;
(((rt)->u.fld[5]).rt_int) = arg5;
(((rt)->u.fld[6]).rt_rtx) = arg6;
return rt;
}
static inline rtx
gen_rtx_fmt_uuBeiie_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3,
int arg4,
int arg5,
rtx arg6 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_uuBeiie (rt, mode, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static inline rtx
init_rtx_fmt_uuBeiie0 (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3,
int arg4,
int arg5,
rtx arg6)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_bb) = arg2;
(((rt)->u.fld[3]).rt_rtx) = arg3;
(((rt)->u.fld[4]).rt_int) = arg4;
(((rt)->u.fld[5]).rt_int) = arg5;
(((rt)->u.fld[6]).rt_rtx) = arg6;
(((rt)->u.fld[7]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_uuBeiie0_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3,
int arg4,
int arg5,
rtx arg6 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_uuBeiie0 (rt, mode, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static inline rtx
init_rtx_fmt_uuBeiiee (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3,
int arg4,
int arg5,
rtx arg6,
rtx arg7)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_bb) = arg2;
(((rt)->u.fld[3]).rt_rtx) = arg3;
(((rt)->u.fld[4]).rt_int) = arg4;
(((rt)->u.fld[5]).rt_int) = arg5;
(((rt)->u.fld[6]).rt_rtx) = arg6;
(((rt)->u.fld[7]).rt_rtx) = arg7;
return rt;
}
static inline rtx
gen_rtx_fmt_uuBeiiee_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3,
int arg4,
int arg5,
rtx arg6,
rtx arg7 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_uuBeiiee (rt, mode, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
static inline rtx
init_rtx_fmt_uuBe0000 (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_bb) = arg2;
(((rt)->u.fld[3]).rt_rtx) = arg3;
(((rt)->u.fld[4]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[5]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[6]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[7]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_uuBe0000_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
rtx arg3 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_uuBe0000 (rt, mode, arg0, arg1, arg2, arg3);
}
static inline rtx
init_rtx_fmt_uu00000 (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[3]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[4]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[5]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[6]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_uu00000_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_uu00000 (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_uuB00is (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
int arg3,
const char *arg4)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_bb) = arg2;
(((rt)->u.fld[3]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[4]).rt_rtx) = (rtx) 0;
(((rt)->u.fld[5]).rt_int) = arg3;
(((rt)->u.fld[6]).rt_str) = arg4;
return rt;
}
static inline rtx
gen_rtx_fmt_uuB00is_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1,
basic_block arg2,
int arg3,
const char *arg4 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_uuB00is (rt, mode, arg0, arg1, arg2, arg3, arg4);
}
static inline rtx
init_rtx_fmt_si (rtx rt, machine_mode mode,
const char *arg0,
int arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_int) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_si_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
int arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_si (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_ssiEEEi (rtx rt, machine_mode mode,
const char *arg0,
const char *arg1,
int arg2,
rtvec arg3,
rtvec arg4,
rtvec arg5,
int arg6)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
(((rt)->u.fld[2]).rt_int) = arg2;
(((rt)->u.fld[3]).rt_rtvec) = arg3;
(((rt)->u.fld[4]).rt_rtvec) = arg4;
(((rt)->u.fld[5]).rt_rtvec) = arg5;
(((rt)->u.fld[6]).rt_int) = arg6;
return rt;
}
static inline rtx
gen_rtx_fmt_ssiEEEi_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
const char *arg1,
int arg2,
rtvec arg3,
rtvec arg4,
rtvec arg5,
int arg6 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ssiEEEi (rt, mode, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static inline rtx
init_rtx_fmt_Ei (rtx rt, machine_mode mode,
rtvec arg0,
int arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtvec) = arg0;
(((rt)->u.fld[1]).rt_int) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_Ei_stat (enum rtx_code code, machine_mode mode,
rtvec arg0,
int arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_Ei (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_eEee0 (rtx rt, machine_mode mode,
rtx arg0,
rtvec arg1,
rtx arg2,
rtx arg3)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtvec) = arg1;
(((rt)->u.fld[2]).rt_rtx) = arg2;
(((rt)->u.fld[3]).rt_rtx) = arg3;
(((rt)->u.fld[4]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_eEee0_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtvec arg1,
rtx arg2,
rtx arg3 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_eEee0 (rt, mode, arg0, arg1, arg2, arg3);
}
static inline rtx
init_rtx_fmt_eee (rtx rt, machine_mode mode,
rtx arg0,
rtx arg1,
rtx arg2)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_rtx) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_eee_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtx arg1,
rtx arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_eee (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_e (rtx rt, machine_mode mode,
rtx arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_e_stat (enum rtx_code code, machine_mode mode,
rtx arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_e (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_ (rtx rt, machine_mode mode)
{
((rt)->mode = (mode));
return rt;
}
static inline rtx
gen_rtx_fmt__stat (enum rtx_code code, machine_mode mode )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ (rt, mode);
}
static inline rtx
init_rtx_fmt_w (rtx rt, machine_mode mode,
long arg0)
{
((rt)->mode = (mode));
((rt)->u.hwint[0]) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_w_stat (enum rtx_code code, machine_mode mode,
long arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_w (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_www (rtx rt, machine_mode mode,
long arg0,
long arg1,
long arg2)
{
((rt)->mode = (mode));
((rt)->u.hwint[0]) = arg0;
((rt)->u.hwint[1]) = arg1;
((rt)->u.hwint[2]) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_www_stat (enum rtx_code code, machine_mode mode,
long arg0,
long arg1,
long arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_www (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_s (rtx rt, machine_mode mode,
const char *arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_s_stat (enum rtx_code code, machine_mode mode,
const char *arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_s (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_ep (rtx rt, machine_mode mode,
rtx arg0,
poly_uint16 arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_subreg) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_ep_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
poly_uint16 arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ep (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_e0 (rtx rt, machine_mode mode,
rtx arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_e0_stat (enum rtx_code code, machine_mode mode,
rtx arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_e0 (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_u (rtx rt, machine_mode mode,
rtx arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_u_stat (enum rtx_code code, machine_mode mode,
rtx arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_u (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_s0 (rtx rt, machine_mode mode,
const char *arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_rtx) = (rtx) 0;
return rt;
}
static inline rtx
gen_rtx_fmt_s0_stat (enum rtx_code code, machine_mode mode,
const char *arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_s0 (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_te (rtx rt, machine_mode mode,
tree arg0,
rtx arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_tree) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_te_stat (enum rtx_code code, machine_mode mode,
tree arg0,
rtx arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_te (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_t (rtx rt, machine_mode mode,
tree arg0)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_tree) = arg0;
return rt;
}
static inline rtx
gen_rtx_fmt_t_stat (enum rtx_code code, machine_mode mode,
tree arg0 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_t (rt, mode, arg0);
}
static inline rtx
init_rtx_fmt_iss (rtx rt, machine_mode mode,
int arg0,
const char *arg1,
const char *arg2)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_int) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
(((rt)->u.fld[2]).rt_str) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_iss_stat (enum rtx_code code, machine_mode mode,
int arg0,
const char *arg1,
const char *arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_iss (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_is (rtx rt, machine_mode mode,
int arg0,
const char *arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_int) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_is_stat (enum rtx_code code, machine_mode mode,
int arg0,
const char *arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_is (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_isE (rtx rt, machine_mode mode,
int arg0,
const char *arg1,
rtvec arg2)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_int) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
(((rt)->u.fld[2]).rt_rtvec) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_isE_stat (enum rtx_code code, machine_mode mode,
int arg0,
const char *arg1,
rtvec arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_isE (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_iE (rtx rt, machine_mode mode,
int arg0,
rtvec arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_int) = arg0;
(((rt)->u.fld[1]).rt_rtvec) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_iE_stat (enum rtx_code code, machine_mode mode,
int arg0,
rtvec arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_iE (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_ss (rtx rt, machine_mode mode,
const char *arg0,
const char *arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_ss_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
const char *arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ss (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_eE (rtx rt, machine_mode mode,
rtx arg0,
rtvec arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtx) = arg0;
(((rt)->u.fld[1]).rt_rtvec) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_eE_stat (enum rtx_code code, machine_mode mode,
rtx arg0,
rtvec arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_eE (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_ses (rtx rt, machine_mode mode,
const char *arg0,
rtx arg1,
const char *arg2)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
(((rt)->u.fld[2]).rt_str) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_ses_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
rtx arg1,
const char *arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ses (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_sss (rtx rt, machine_mode mode,
const char *arg0,
const char *arg1,
const char *arg2)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
(((rt)->u.fld[2]).rt_str) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_sss_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
const char *arg1,
const char *arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_sss (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_sse (rtx rt, machine_mode mode,
const char *arg0,
const char *arg1,
rtx arg2)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
(((rt)->u.fld[2]).rt_rtx) = arg2;
return rt;
}
static inline rtx
gen_rtx_fmt_sse_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
const char *arg1,
rtx arg2 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_sse (rt, mode, arg0, arg1, arg2);
}
static inline rtx
init_rtx_fmt_sies (rtx rt, machine_mode mode,
const char *arg0,
int arg1,
rtx arg2,
const char *arg3)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_int) = arg1;
(((rt)->u.fld[2]).rt_rtx) = arg2;
(((rt)->u.fld[3]).rt_str) = arg3;
return rt;
}
static inline rtx
gen_rtx_fmt_sies_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
int arg1,
rtx arg2,
const char *arg3 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_sies (rt, mode, arg0, arg1, arg2, arg3);
}
static inline rtx
init_rtx_fmt_sE (rtx rt, machine_mode mode,
const char *arg0,
rtvec arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_rtvec) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_sE_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
rtvec arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_sE (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_ww (rtx rt, machine_mode mode,
long arg0,
long arg1)
{
((rt)->mode = (mode));
((rt)->u.hwint[0]) = arg0;
((rt)->u.hwint[1]) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_ww_stat (enum rtx_code code, machine_mode mode,
long arg0,
long arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ww (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_Ee (rtx rt, machine_mode mode,
rtvec arg0,
rtx arg1)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_rtvec) = arg0;
(((rt)->u.fld[1]).rt_rtx) = arg1;
return rt;
}
static inline rtx
gen_rtx_fmt_Ee_stat (enum rtx_code code, machine_mode mode,
rtvec arg0,
rtx arg1 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_Ee (rt, mode, arg0, arg1);
}
static inline rtx
init_rtx_fmt_sEsE (rtx rt, machine_mode mode,
const char *arg0,
rtvec arg1,
const char *arg2,
rtvec arg3)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_rtvec) = arg1;
(((rt)->u.fld[2]).rt_str) = arg2;
(((rt)->u.fld[3]).rt_rtvec) = arg3;
return rt;
}
static inline rtx
gen_rtx_fmt_sEsE_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
rtvec arg1,
const char *arg2,
rtvec arg3 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_sEsE (rt, mode, arg0, arg1, arg2, arg3);
}
static inline rtx
init_rtx_fmt_ssss (rtx rt, machine_mode mode,
const char *arg0,
const char *arg1,
const char *arg2,
const char *arg3)
{
((rt)->mode = (mode));
(((rt)->u.fld[0]).rt_str) = arg0;
(((rt)->u.fld[1]).rt_str) = arg1;
(((rt)->u.fld[2]).rt_str) = arg2;
(((rt)->u.fld[3]).rt_str) = arg3;
return rt;
}
static inline rtx
gen_rtx_fmt_ssss_stat (enum rtx_code code, machine_mode mode,
const char *arg0,
const char *arg1,
const char *arg2,
const char *arg3 )
{
rtx rt;
rt = rtx_alloc (code );
return init_rtx_fmt_ssss (rt, mode, arg0, arg1, arg2, arg3);
}
# 3810 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h" 2
# 3821 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern rtx_expr_list *gen_rtx_EXPR_LIST (machine_mode, rtx, rtx);
extern rtx_insn_list *gen_rtx_INSN_LIST (machine_mode, rtx, rtx);
extern rtx_insn *
gen_rtx_INSN (machine_mode mode, rtx_insn *prev_insn, rtx_insn *next_insn,
basic_block bb, rtx pattern, int location, int code,
rtx reg_notes);
extern rtx gen_rtx_CONST_INT (machine_mode, long);
extern rtx gen_rtx_CONST_VECTOR (machine_mode, rtvec);
extern void set_mode_and_regno (rtx, machine_mode, unsigned int);
extern rtx init_raw_REG (rtx, machine_mode, unsigned int);
extern rtx gen_raw_REG (machine_mode, unsigned int);
extern rtx gen_rtx_REG (machine_mode, unsigned int);
extern rtx gen_rtx_SUBREG (machine_mode, rtx, poly_uint64);
extern rtx gen_rtx_MEM (machine_mode, rtx);
extern rtx gen_rtx_VAR_LOCATION (machine_mode, tree, rtx,
enum var_init_status);
static inline void
PUT_MODE (rtx x, machine_mode mode)
{
if ((((enum rtx_code) (x)->code) == REG))
set_mode_and_regno (x, mode, (rhs_regno(x)));
else
((x)->mode = (mode));
}
# 3933 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern rtx output_constant_def (tree, int);
extern rtx lookup_constant_def (tree);
extern int reload_completed;
extern int epilogue_completed;
extern int reload_in_progress;
extern int lra_in_progress;
# 3960 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern int regstack_completed;
# 3969 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
extern int cse_not_expected;
extern int rtx_to_tree_code (enum rtx_code);
extern int delete_trivially_dead_insns (rtx_insn *, int);
extern int exp_equiv_p (const_rtx, const_rtx, int, bool);
extern unsigned hash_rtx (const_rtx x, machine_mode, int *, int *, bool);
extern bool check_for_inc_dec (rtx_insn *insn);
extern int comparison_dominates_p (enum rtx_code, enum rtx_code);
extern bool jump_to_label_p (const rtx_insn *);
extern int condjump_p (const rtx_insn *);
extern int any_condjump_p (const rtx_insn *);
extern int any_uncondjump_p (const rtx_insn *);
extern rtx pc_set (const rtx_insn *);
extern rtx condjump_label (const rtx_insn *);
extern int simplejump_p (const rtx_insn *);
extern int returnjump_p (const rtx_insn *);
extern int eh_returnjump_p (rtx_insn *);
extern int onlyjump_p (const rtx_insn *);
extern int only_sets_cc0_p (const_rtx);
extern int sets_cc0_p (const_rtx);
extern int invert_jump_1 (rtx_jump_insn *, rtx);
extern int invert_jump (rtx_jump_insn *, rtx, int);
extern int rtx_renumbered_equal_p (const_rtx, const_rtx);
extern int true_regnum (const_rtx);
extern unsigned int reg_or_subregno (const_rtx);
extern int redirect_jump_1 (rtx_insn *, rtx);
extern void redirect_jump_2 (rtx_jump_insn *, rtx, rtx, int, int);
extern int redirect_jump (rtx_jump_insn *, rtx, int);
extern void rebuild_jump_labels (rtx_insn *);
extern void rebuild_jump_labels_chain (rtx_insn *);
extern rtx reversed_comparison (const_rtx, machine_mode);
extern enum rtx_code reversed_comparison_code (const_rtx, const rtx_insn *);
extern enum rtx_code reversed_comparison_code_parts (enum rtx_code, const_rtx,
const_rtx, const rtx_insn *);
extern void delete_for_peephole (rtx_insn *, rtx_insn *);
extern int condjump_in_parallel_p (const rtx_insn *);
extern int max_reg_num (void);
extern int max_label_num (void);
extern int get_first_label_num (void);
extern void maybe_set_first_label_num (rtx_code_label *);
extern void delete_insns_since (rtx_insn *);
extern void mark_reg_pointer (rtx, int);
extern void mark_user_reg (rtx);
extern void reset_used_flags (rtx);
extern void set_used_flags (rtx);
extern void reorder_insns (rtx_insn *, rtx_insn *, rtx_insn *);
extern void reorder_insns_nobb (rtx_insn *, rtx_insn *, rtx_insn *);
extern int get_max_insn_count (void);
extern int in_sequence_p (void);
extern void init_emit (void);
extern void init_emit_regs (void);
extern void init_derived_machine_modes (void);
extern void init_emit_once (void);
extern void push_topmost_sequence (void);
extern void pop_topmost_sequence (void);
extern void set_new_first_and_last_insn (rtx_insn *, rtx_insn *);
extern unsigned int unshare_all_rtl (void);
extern void unshare_all_rtl_again (rtx_insn *);
extern void unshare_all_rtl_in_chain (rtx_insn *);
extern void verify_rtl_sharing (void);
extern void add_insn (rtx_insn *);
extern void add_insn_before (rtx_insn *, rtx_insn *, basic_block);
extern void add_insn_after (rtx_insn *, rtx_insn *, basic_block);
extern void remove_insn (rtx_insn *);
extern rtx_insn *emit (rtx, bool = true);
extern void emit_insn_at_entry (rtx);
extern rtx gen_lowpart_SUBREG (machine_mode, rtx);
extern rtx gen_const_mem (machine_mode, rtx);
extern rtx gen_frame_mem (machine_mode, rtx);
extern rtx gen_tmp_stack_mem (machine_mode, rtx);
extern bool validate_subreg (machine_mode, machine_mode,
const_rtx, poly_uint64);
extern unsigned int extended_count (const_rtx, machine_mode, int);
extern rtx remove_death (unsigned int, rtx_insn *);
extern void dump_combine_stats (FILE *);
extern void dump_combine_total_stats (FILE *);
extern rtx make_compound_operation (rtx, enum rtx_code);
extern void schedule_insns (void);
extern void schedule_ebbs (void);
extern void sel_sched_fix_param (const char *param, const char *val);
extern const char *print_rtx_head;
extern void debug (const rtx_def &ref);
extern void debug (const rtx_def *ptr);
extern void debug_rtx (const_rtx);
extern void debug_rtx_list (const rtx_insn *, int);
extern void debug_rtx_range (const rtx_insn *, const rtx_insn *);
extern const rtx_insn *debug_rtx_find (const rtx_insn *, int);
extern void print_mem_expr (FILE *, const_tree);
extern void print_rtl (FILE *, const_rtx);
extern void print_simple_rtl (FILE *, const_rtx);
extern int print_rtl_single (FILE *, const_rtx);
extern int print_rtl_single_with_indent (FILE *, const_rtx, int);
extern void print_inline_rtx (FILE *, const_rtx, int);
extern void expand_null_return (void);
extern void expand_naked_return (void);
extern void emit_jump (rtx);
# 4098 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
enum memop_ret
{
RETURN_BEGIN,
RETURN_END,
RETURN_END_MINUS_ONE
};
extern rtx move_by_pieces (rtx, rtx, unsigned long,
unsigned int, memop_ret);
extern poly_int64 find_args_size_adjust (rtx_insn *);
extern poly_int64 fixup_args_size_notes (rtx_insn *, rtx_insn *, poly_int64);
extern void init_expmed (void);
extern void expand_inc (rtx, rtx);
extern void expand_dec (rtx, rtx);
extern void init_lower_subreg (void);
extern bool can_copy_p (machine_mode);
extern bool can_assign_to_reg_without_clobbers_p (rtx, machine_mode);
extern rtx_insn *prepare_copy_insn (rtx, rtx);
extern rtx fis_get_condition (rtx_insn *);
extern HARD_REG_SET eliminable_regset;
extern void mark_elimination (int, int);
extern int reg_classes_intersect_p (reg_class_t, reg_class_t);
extern int reg_class_subset_p (reg_class_t, reg_class_t);
extern void globalize_reg (tree, int);
extern void init_reg_modes_target (void);
extern void init_regs (void);
extern void reinit_regs (void);
extern void init_fake_stack_mems (void);
extern void save_register_info (void);
extern void init_reg_sets (void);
extern void regclass (rtx, int);
extern void reg_scan (rtx_insn *, unsigned int);
extern void fix_register (const char *, int, int);
extern const HARD_REG_SET *valid_mode_changes_for_regno (unsigned int);
extern int function_invariant_p (const_rtx);
enum libcall_type
{
LCT_NORMAL = 0,
LCT_CONST = 1,
LCT_PURE = 2,
LCT_NORETURN = 3,
LCT_THROW = 4,
LCT_RETURNS_TWICE = 5
};
extern rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
machine_mode, int, rtx_mode_t *);
# 4172 "/home/giulianob/gcc_git_gnu/gcc/gcc/rtl.h"
inline void
emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode)
{
emit_library_call_value_1 (0, fun, (rtx) 0, fn_type, outmode, 0, nullptr);
}
inline void
emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
rtx arg1, machine_mode arg1_mode)
{
rtx_mode_t args[] = { rtx_mode_t (arg1, arg1_mode) };
emit_library_call_value_1 (0, fun, (rtx) 0, fn_type, outmode, 1, args);
}
inline void
emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
rtx arg1, machine_mode arg1_mode,
rtx arg2, machine_mode arg2_mode)
{
rtx_mode_t args[] = {
rtx_mode_t (arg1, arg1_mode),
rtx_mode_t (arg2, arg2_mode)
};
emit_library_call_value_1 (0, fun, (rtx) 0, fn_type, outmode, 2, args);
}
inline void
emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
rtx arg1, machine_mode arg1_mode,
rtx arg2, machine_mode arg2_mode,
rtx arg3, machine_mode arg3_mode)
{
rtx_mode_t args[] = {
rtx_mode_t (arg1, arg1_mode),
rtx_mode_t (arg2, arg2_mode),
rtx_mode_t (arg3, arg3_mode)
};
emit_library_call_value_1 (0, fun, (rtx) 0, fn_type, outmode, 3, args);
}
inline void
emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
rtx arg1, machine_mode arg1_mode,
rtx arg2, machine_mode arg2_mode,
rtx arg3, machine_mode arg3_mode,
rtx arg4, machine_mode arg4_mode)
{
rtx_mode_t args[] = {
rtx_mode_t (arg1, arg1_mode),
rtx_mode_t (arg2, arg2_mode),
rtx_mode_t (arg3, arg3_mode),
rtx_mode_t (arg4, arg4_mode)
};
emit_library_call_value_1 (0, fun, (rtx) 0, fn_type, outmode, 4, args);
}
inline rtx
emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
machine_mode outmode)
{
return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 0, nullptr);
}
inline rtx
emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
machine_mode outmode,
rtx arg1, machine_mode arg1_mode)
{
rtx_mode_t args[] = { rtx_mode_t (arg1, arg1_mode) };
return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 1, args);
}
inline rtx
emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
machine_mode outmode,
rtx arg1, machine_mode arg1_mode,
rtx arg2, machine_mode arg2_mode)
{
rtx_mode_t args[] = {
rtx_mode_t (arg1, arg1_mode),
rtx_mode_t (arg2, arg2_mode)
};
return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 2, args);
}
inline rtx
emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
machine_mode outmode,
rtx arg1, machine_mode arg1_mode,
rtx arg2, machine_mode arg2_mode,
rtx arg3, machine_mode arg3_mode)
{
rtx_mode_t args[] = {
rtx_mode_t (arg1, arg1_mode),
rtx_mode_t (arg2, arg2_mode),
rtx_mode_t (arg3, arg3_mode)
};
return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 3, args);
}
inline rtx
emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
machine_mode outmode,
rtx arg1, machine_mode arg1_mode,
rtx arg2, machine_mode arg2_mode,
rtx arg3, machine_mode arg3_mode,
rtx arg4, machine_mode arg4_mode)
{
rtx_mode_t args[] = {
rtx_mode_t (arg1, arg1_mode),
rtx_mode_t (arg2, arg2_mode),
rtx_mode_t (arg3, arg3_mode),
rtx_mode_t (arg4, arg4_mode)
};
return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 4, args);
}
extern void init_varasm_once (void);
extern rtx make_debug_expr_from_rtl (const_rtx);
extern rtx canon_rtx (rtx);
extern int true_dependence (const_rtx, machine_mode, const_rtx);
extern rtx get_addr (rtx);
extern int canon_true_dependence (const_rtx, machine_mode, rtx,
const_rtx, rtx);
extern int read_dependence (const_rtx, const_rtx);
extern int anti_dependence (const_rtx, const_rtx);
extern int canon_anti_dependence (const_rtx, bool,
const_rtx, machine_mode, rtx);
extern int output_dependence (const_rtx, const_rtx);
extern int canon_output_dependence (const_rtx, bool,
const_rtx, machine_mode, rtx);
extern int may_alias_p (const_rtx, const_rtx);
extern void init_alias_target (void);
extern void init_alias_analysis (void);
extern void end_alias_analysis (void);
extern void vt_equate_reg_base_value (const_rtx, const_rtx);
extern bool memory_modified_in_insn_p (const_rtx, const_rtx);
extern bool may_be_sp_based_p (rtx);
extern rtx gen_hard_reg_clobber (machine_mode, unsigned int);
extern rtx get_reg_known_value (unsigned int);
extern bool get_reg_known_equiv_p (unsigned int);
extern rtx get_reg_base_value (unsigned int);
extern int stack_regs_mentioned (const_rtx insn);
extern rtx stack_limit_rtx;
extern unsigned int variable_tracking_main (void);
extern void delete_vta_debug_insns (bool);
extern void get_mode_bounds (scalar_int_mode, int,
scalar_int_mode, rtx *, rtx *);
extern rtx canon_condition (rtx);
extern void simplify_using_condition (rtx, rtx *, bitmap);
extern unsigned int compute_alignments (void);
extern void update_alignments (vec<rtx> &);
extern int asm_str_count (const char *templ);
struct rtl_hooks
{
rtx (*gen_lowpart) (machine_mode, rtx);
rtx (*gen_lowpart_no_emit) (machine_mode, rtx);
rtx (*reg_nonzero_bits) (const_rtx, scalar_int_mode, scalar_int_mode,
unsigned long *);
rtx (*reg_num_sign_bit_copies) (const_rtx, scalar_int_mode, scalar_int_mode,
unsigned int *);
bool (*reg_truncated_to_mode) (machine_mode, const_rtx);
};
extern struct rtl_hooks rtl_hooks;
extern const struct rtl_hooks general_rtl_hooks;
extern void insn_locations_init (void);
extern void insn_locations_finalize (void);
extern void set_curr_insn_location (location_t);
extern location_t curr_insn_location (void);
extern void set_insn_locations (rtx_insn *, location_t);
extern void _fatal_insn_not_found (const_rtx, const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void _fatal_insn (const char *, const_rtx, const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern tree global_regs_decl[76];
struct cgraph_rtl_info {
unsigned int preferred_incoming_stack_boundary;
HARD_REG_SET function_used_regs;
};
inline rtx_code
load_extend_op (machine_mode mode)
{
scalar_int_mode int_mode;
if (is_a <scalar_int_mode> (mode, &int_mode)
&& GET_MODE_PRECISION (int_mode) < ((8) * (((global_options.x_ix86_isa_flags & (1UL << 1)) != 0) ? 8 : 4)))
return UNKNOWN;
return UNKNOWN;
}
inline rtx
strip_offset_and_add (rtx x, poly_int64_pod *offset)
{
if (((enum rtx_code) (x)->code) == PLUS)
{
poly_int64 suboffset;
x = strip_offset (x, &suboffset);
*offset = poly_uint64 (*offset) + suboffset;
}
return x;
}
inline bool
word_register_operation_p (const_rtx x)
{
switch (((enum rtx_code) (x)->code))
{
case CONST_INT:
case ROTATE:
case ROTATERT:
case SIGN_EXTRACT:
case ZERO_EXTRACT:
return false;
default:
return true;
}
}
extern void gt_ggc_mx (rtx &);
extern void gt_pch_nx (rtx &);
extern void gt_pch_nx (rtx &, gt_pointer_operator, void *);
# 99 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/symtab.h" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/../libcpp/include/symtab.h"
typedef struct ht_identifier ht_identifier;
typedef struct ht_identifier *ht_identifier_ptr;
struct ht_identifier {
const unsigned char *str;
unsigned int len;
unsigned int hash_value;
};
typedef struct ht cpp_hash_table;
typedef struct ht_identifier *hashnode;
enum ht_lookup_option {HT_NO_INSERT = 0, HT_ALLOC};
struct ht
{
struct obstack stack;
hashnode *entries;
hashnode (*alloc_node) (cpp_hash_table *);
void * (*alloc_subobject) (size_t);
unsigned int nslots;
unsigned int nelements;
struct cpp_reader *pfile;
unsigned int searches;
unsigned int collisions;
bool entries_owned;
};
extern cpp_hash_table *ht_create (unsigned int order);
extern void ht_destroy (cpp_hash_table *);
extern hashnode ht_lookup (cpp_hash_table *, const unsigned char *,
size_t, enum ht_lookup_option);
extern hashnode ht_lookup_with_hash (cpp_hash_table *, const unsigned char *,
size_t, unsigned int,
enum ht_lookup_option);
typedef int (*ht_cb) (struct cpp_reader *, hashnode, const void *);
extern void ht_forall (cpp_hash_table *, ht_cb, const void *);
extern void ht_purge (cpp_hash_table *, ht_cb, const void *);
extern void ht_load (cpp_hash_table *ht, hashnode *entries,
unsigned int nslots, unsigned int nelements, bool own);
extern void ht_dump_statistics (cpp_hash_table *);
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
struct function;
struct real_value;
struct fixed_value;
struct ptr_info_def;
struct range_info_def;
struct die_struct;
# 134 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
enum tree_code {
# 1 "./all-tree.def" 1
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def" 1
# 41 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
ERROR_MARK,
IDENTIFIER_NODE,
TREE_LIST,
TREE_VEC,
# 75 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
BLOCK,
# 122 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
OFFSET_TYPE,
# 135 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
ENUMERAL_TYPE,
BOOLEAN_TYPE,
INTEGER_TYPE,
REAL_TYPE,
# 158 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
POINTER_TYPE,
REFERENCE_TYPE,
NULLPTR_TYPE,
FIXED_POINT_TYPE,
# 179 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
COMPLEX_TYPE,
VECTOR_TYPE,
# 200 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
ARRAY_TYPE,
# 210 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
RECORD_TYPE,
UNION_TYPE,
QUAL_UNION_TYPE,
VOID_TYPE,
# 239 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
FUNCTION_TYPE,
METHOD_TYPE,
LANG_TYPE,
VOID_CST,
# 278 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
INTEGER_CST,
POLY_INT_CST,
REAL_CST,
FIXED_CST,
COMPLEX_CST,
VECTOR_CST,
STRING_CST,
# 357 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
FUNCTION_DECL,
LABEL_DECL,
FIELD_DECL,
VAR_DECL,
CONST_DECL,
PARM_DECL,
TYPE_DECL,
RESULT_DECL,
DEBUG_EXPR_DECL,
DEBUG_BEGIN_STMT,
NAMESPACE_DECL,
# 390 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
IMPORTED_DECL,
# 400 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
NAMELIST_DECL,
TRANSLATION_UNIT_DECL,
# 417 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
COMPONENT_REF,
# 427 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
BIT_FIELD_REF,
ARRAY_REF,
ARRAY_RANGE_REF,
REALPART_EXPR,
IMAGPART_EXPR,
# 456 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
VIEW_CONVERT_EXPR,
INDIRECT_REF,
# 468 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
OBJ_TYPE_REF,
# 487 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
CONSTRUCTOR,
# 497 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
COMPOUND_EXPR,
MODIFY_EXPR,
INIT_EXPR,
TARGET_EXPR,
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
COND_EXPR,
VEC_DUPLICATE_EXPR,
# 540 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
VEC_SERIES_EXPR,
# 552 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
VEC_COND_EXPR,
# 566 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
VEC_PERM_EXPR,
# 589 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
BIND_EXPR,
CALL_EXPR,
WITH_CLEANUP_EXPR,
# 621 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
CLEANUP_POINT_EXPR,
# 673 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
PLACEHOLDER_EXPR,
PLUS_EXPR,
MINUS_EXPR,
MULT_EXPR,
POINTER_PLUS_EXPR,
POINTER_DIFF_EXPR,
MULT_HIGHPART_EXPR,
TRUNC_DIV_EXPR,
CEIL_DIV_EXPR,
FLOOR_DIV_EXPR,
ROUND_DIV_EXPR,
TRUNC_MOD_EXPR,
CEIL_MOD_EXPR,
FLOOR_MOD_EXPR,
ROUND_MOD_EXPR,
RDIV_EXPR,
EXACT_DIV_EXPR,
FIX_TRUNC_EXPR,
FLOAT_EXPR,
NEGATE_EXPR,
MIN_EXPR,
MAX_EXPR,
ABS_EXPR,
ABSU_EXPR,
# 768 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
LSHIFT_EXPR,
RSHIFT_EXPR,
LROTATE_EXPR,
RROTATE_EXPR,
BIT_IOR_EXPR,
BIT_XOR_EXPR,
BIT_AND_EXPR,
BIT_NOT_EXPR,
# 788 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
TRUTH_ANDIF_EXPR,
TRUTH_ORIF_EXPR,
TRUTH_AND_EXPR,
TRUTH_OR_EXPR,
TRUTH_XOR_EXPR,
TRUTH_NOT_EXPR,
# 807 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
LT_EXPR,
LE_EXPR,
GT_EXPR,
GE_EXPR,
LTGT_EXPR,
EQ_EXPR,
NE_EXPR,
UNORDERED_EXPR,
ORDERED_EXPR,
UNLT_EXPR,
UNLE_EXPR,
UNGT_EXPR,
UNGE_EXPR,
UNEQ_EXPR,
RANGE_EXPR,
PAREN_EXPR,
CONVERT_EXPR,
ADDR_SPACE_CONVERT_EXPR,
FIXED_CONVERT_EXPR,
NOP_EXPR,
NON_LVALUE_EXPR,
COMPOUND_LITERAL_EXPR,
SAVE_EXPR,
ADDR_EXPR,
FDESC_EXPR,
# 885 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
BIT_INSERT_EXPR,
COMPLEX_EXPR,
CONJ_EXPR,
PREDECREMENT_EXPR,
PREINCREMENT_EXPR,
POSTDECREMENT_EXPR,
POSTINCREMENT_EXPR,
VA_ARG_EXPR,
TRY_CATCH_EXPR,
TRY_FINALLY_EXPR,
EH_ELSE_EXPR,
DECL_EXPR,
LABEL_EXPR,
GOTO_EXPR,
RETURN_EXPR,
EXIT_EXPR,
LOOP_EXPR,
# 965 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
SWITCH_EXPR,
# 977 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
CASE_LABEL_EXPR,
ASM_EXPR,
SSA_NAME,
CATCH_EXPR,
EH_FILTER_EXPR,
SCEV_KNOWN,
SCEV_NOT_KNOWN,
POLYNOMIAL_CHREC,
STATEMENT_LIST,
# 1033 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
ASSERT_EXPR,
TREE_BINFO,
WITH_SIZE_EXPR,
# 1055 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
REALIGN_LOAD_EXPR,
# 1071 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
TARGET_MEM_REF,
# 1081 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
MEM_REF,
# 1090 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
OACC_PARALLEL,
OACC_KERNELS,
OACC_SERIAL,
OACC_DATA,
OACC_HOST_DATA,
OMP_PARALLEL,
OMP_TASK,
# 1152 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
OMP_FOR,
OMP_SIMD,
OMP_DISTRIBUTE,
OMP_TASKLOOP,
OMP_LOOP,
OACC_LOOP,
OMP_TEAMS,
OMP_TARGET_DATA,
OMP_TARGET,
OMP_SECTIONS,
OMP_ORDERED,
OMP_CRITICAL,
OMP_SINGLE,
OMP_TASKGROUP,
OMP_SCAN,
OMP_SECTION,
OMP_MASTER,
OACC_CACHE,
OACC_DECLARE,
OACC_ENTER_DATA,
OACC_EXIT_DATA,
OACC_UPDATE,
OMP_TARGET_UPDATE,
OMP_TARGET_ENTER_DATA,
OMP_TARGET_EXIT_DATA,
# 1270 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
OMP_ATOMIC,
OMP_ATOMIC_READ,
# 1285 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
OMP_ATOMIC_CAPTURE_OLD,
OMP_ATOMIC_CAPTURE_NEW,
OMP_CLAUSE,
TRANSACTION_EXPR,
# 1304 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
DOT_PROD_EXPR,
# 1313 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
WIDEN_SUM_EXPR,
# 1329 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
SAD_EXPR,
WIDEN_MULT_EXPR,
# 1345 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
WIDEN_MULT_PLUS_EXPR,
WIDEN_MULT_MINUS_EXPR,
# 1361 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
WIDEN_LSHIFT_EXPR,
VEC_WIDEN_MULT_HI_EXPR,
VEC_WIDEN_MULT_LO_EXPR,
VEC_WIDEN_MULT_EVEN_EXPR,
VEC_WIDEN_MULT_ODD_EXPR,
VEC_UNPACK_HI_EXPR,
VEC_UNPACK_LO_EXPR,
VEC_UNPACK_FLOAT_HI_EXPR,
VEC_UNPACK_FLOAT_LO_EXPR,
VEC_UNPACK_FIX_TRUNC_HI_EXPR,
VEC_UNPACK_FIX_TRUNC_LO_EXPR,
VEC_PACK_TRUNC_EXPR,
VEC_PACK_SAT_EXPR,
VEC_PACK_FIX_TRUNC_EXPR,
VEC_PACK_FLOAT_EXPR,
# 1424 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.def"
VEC_WIDEN_LSHIFT_HI_EXPR,
VEC_WIDEN_LSHIFT_LO_EXPR,
PREDICT_EXPR,
OPTIMIZATION_NODE,
TARGET_OPTION_NODE,
ANNOTATE_EXPR,
# 2 "./all-tree.def" 2
LAST_AND_UNUSED_TREE_CODE,
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/c-family/c-common.def" 1
# 39 "/home/giulianob/gcc_git_gnu/gcc/gcc/c-family/c-common.def"
C_MAYBE_CONST_EXPR,
EXCESS_PRECISION_EXPR,
USERDEF_LITERAL,
SIZEOF_EXPR,
# 4 "./all-tree.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/ada/gcc-interface/ada-tree.def" 1
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/ada/gcc-interface/ada-tree.def"
UNCONSTRAINED_ARRAY_TYPE,
UNCONSTRAINED_ARRAY_REF,
NULL_EXPR,
PLUS_NOMOD_EXPR,
MINUS_NOMOD_EXPR,
POWER_EXPR,
ATTR_ADDR_EXPR,
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/ada/gcc-interface/ada-tree.def"
STMT_STMT,
LOOP_STMT,
EXIT_STMT,
# 5 "./all-tree.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def" 1
# 41 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
OFFSET_REF,
PTRMEM_CST,
NEW_EXPR,
VEC_NEW_EXPR,
DELETE_EXPR,
VEC_DELETE_EXPR,
SCOPE_REF,
MEMBER_REF,
TYPE_EXPR,
AGGR_INIT_EXPR,
VEC_INIT_EXPR,
THROW_EXPR,
EMPTY_CLASS_EXPR,
# 107 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
BASELINK,
# 124 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
TEMPLATE_DECL,
# 159 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
TEMPLATE_PARM_INDEX,
TEMPLATE_TEMPLATE_PARM,
# 176 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
TEMPLATE_TYPE_PARM,
TYPENAME_TYPE,
TYPEOF_TYPE,
BOUND_TEMPLATE_TEMPLATE_PARM,
UNBOUND_CLASS_TEMPLATE,
USING_DECL,
USING_STMT,
DEFERRED_PARSE,
DEFERRED_NOEXCEPT,
TEMPLATE_ID_EXPR,
OVERLOAD,
# 246 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
PSEUDO_DTOR_EXPR,
MODOP_EXPR,
CAST_EXPR,
REINTERPRET_CAST_EXPR,
CONST_CAST_EXPR,
STATIC_CAST_EXPR,
DYNAMIC_CAST_EXPR,
IMPLICIT_CONV_EXPR,
DOTSTAR_EXPR,
TYPEID_EXPR,
NOEXCEPT_EXPR,
SPACESHIP_EXPR,
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
NON_DEPENDENT_EXPR,
CTOR_INITIALIZER,
TRY_BLOCK,
EH_SPEC_BLOCK,
HANDLER,
MUST_NOT_THROW_EXPR,
CLEANUP_STMT,
IF_STMT,
FOR_STMT,
RANGE_FOR_STMT,
WHILE_STMT,
DO_STMT,
BREAK_STMT,
CONTINUE_STMT,
SWITCH_STMT,
EXPR_STMT,
TAG_DEFN,
OFFSETOF_EXPR,
ADDRESSOF_EXPR,
ARROW_EXPR,
ALIGNOF_EXPR,
AT_ENCODE_EXPR,
STMT_EXPR,
UNARY_PLUS_EXPR,
STATIC_ASSERT,
# 391 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
TYPE_ARGUMENT_PACK,
# 400 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
NONTYPE_ARGUMENT_PACK,
# 423 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
TYPE_PACK_EXPANSION,
EXPR_PACK_EXPANSION,
# 442 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
ARGUMENT_PACK_SELECT,
# 458 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
UNARY_LEFT_FOLD_EXPR,
UNARY_RIGHT_FOLD_EXPR,
BINARY_LEFT_FOLD_EXPR,
BINARY_RIGHT_FOLD_EXPR,
TRAIT_EXPR,
# 477 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
LAMBDA_EXPR,
# 486 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
DECLTYPE_TYPE,
UNDERLYING_TYPE,
BASES,
# 504 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
TEMPLATE_INFO,
OMP_DEPOBJ,
CONCEPT_DECL,
CONSTRAINT_INFO,
WILDCARD_DECL,
REQUIRES_EXPR,
SIMPLE_REQ,
TYPE_REQ,
COMPOUND_REQ,
NESTED_REQ,
# 560 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
ATOMIC_CONSTR,
CONJ_CONSTR,
DISJ_CONSTR,
CHECK_CONSTR,
# 588 "/home/giulianob/gcc_git_gnu/gcc/gcc/cp/cp-tree.def"
CO_AWAIT_EXPR,
CO_YIELD_EXPR,
CO_RETURN_EXPR,
# 6 "./all-tree.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/d/d-tree.def" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/d/d-tree.def"
UNSIGNED_RSHIFT_EXPR,
FLOAT_MOD_EXPR,
FUNCFRAME_INFO,
# 7 "./all-tree.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/objc/objc-tree.def" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/objc/objc-tree.def"
CLASS_INTERFACE_TYPE,
CLASS_IMPLEMENTATION_TYPE,
CATEGORY_INTERFACE_TYPE,
CATEGORY_IMPLEMENTATION_TYPE,
PROTOCOL_INTERFACE_TYPE,
KEYWORD_DECL,
INSTANCE_METHOD_DECL,
CLASS_METHOD_DECL,
PROPERTY_DECL,
MESSAGE_SEND_EXPR,
CLASS_REFERENCE_EXPR,
# 70 "/home/giulianob/gcc_git_gnu/gcc/gcc/objc/objc-tree.def"
PROPERTY_REF,
# 8 "./all-tree.def" 2
# 136 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
MAX_TREE_CODES
};
# 152 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
enum built_in_class {
NOT_BUILT_IN = 0,
BUILT_IN_FRONTEND,
BUILT_IN_MD,
BUILT_IN_NORMAL
};
# 166 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
enum built_in_function {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 1
# 282 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def"
BUILT_IN_NONE,
BUILT_IN_ACOS,
BUILT_IN_ACOSF,
BUILT_IN_ACOSH,
BUILT_IN_ACOSHF,
BUILT_IN_ACOSHL,
BUILT_IN_ACOSL,
BUILT_IN_ALIGNED_ALLOC,
BUILT_IN_ASIN,
BUILT_IN_ASINF,
BUILT_IN_ASINH,
BUILT_IN_ASINHF,
BUILT_IN_ASINHL,
BUILT_IN_ASINL,
BUILT_IN_ATAN,
BUILT_IN_ATAN2,
BUILT_IN_ATAN2F,
BUILT_IN_ATAN2L,
BUILT_IN_ATANF,
BUILT_IN_ATANH,
BUILT_IN_ATANHF,
BUILT_IN_ATANHL,
BUILT_IN_ATANL,
BUILT_IN_CBRT,
BUILT_IN_CBRTF,
BUILT_IN_CBRTL,
BUILT_IN_CEIL,
BUILT_IN_CEILF,
BUILT_IN_CEILL,
BUILT_IN_CEILF16, BUILT_IN_CEILF32, BUILT_IN_CEILF64, BUILT_IN_CEILF128, BUILT_IN_CEILF32X, BUILT_IN_CEILF64X, BUILT_IN_CEILF128X,
BUILT_IN_COPYSIGN,
BUILT_IN_COPYSIGNF,
BUILT_IN_COPYSIGNL,
BUILT_IN_COPYSIGNF16, BUILT_IN_COPYSIGNF32, BUILT_IN_COPYSIGNF64, BUILT_IN_COPYSIGNF128, BUILT_IN_COPYSIGNF32X, BUILT_IN_COPYSIGNF64X, BUILT_IN_COPYSIGNF128X,
BUILT_IN_COS,
BUILT_IN_COSF,
BUILT_IN_COSH,
BUILT_IN_COSHF,
BUILT_IN_COSHL,
BUILT_IN_COSL,
BUILT_IN_DREM,
BUILT_IN_DREMF,
BUILT_IN_DREML,
BUILT_IN_ERF,
BUILT_IN_ERFC,
BUILT_IN_ERFCF,
BUILT_IN_ERFCL,
BUILT_IN_ERFF,
BUILT_IN_ERFL,
BUILT_IN_EXP,
BUILT_IN_EXP10,
BUILT_IN_EXP10F,
BUILT_IN_EXP10L,
BUILT_IN_EXP2,
BUILT_IN_EXP2F,
BUILT_IN_EXP2L,
BUILT_IN_EXPF,
BUILT_IN_EXPL,
BUILT_IN_EXPM1,
BUILT_IN_EXPM1F,
BUILT_IN_EXPM1L,
BUILT_IN_FABS,
BUILT_IN_FABSF,
BUILT_IN_FABSL,
BUILT_IN_FABSF16, BUILT_IN_FABSF32, BUILT_IN_FABSF64, BUILT_IN_FABSF128, BUILT_IN_FABSF32X, BUILT_IN_FABSF64X, BUILT_IN_FABSF128X,
BUILT_IN_FABSD32,
BUILT_IN_FABSD64,
BUILT_IN_FABSD128,
BUILT_IN_FDIM,
BUILT_IN_FDIMF,
BUILT_IN_FDIML,
BUILT_IN_FECLEAREXCEPT,
BUILT_IN_FEGETENV,
BUILT_IN_FEGETEXCEPTFLAG,
BUILT_IN_FEGETROUND,
BUILT_IN_FEHOLDEXCEPT,
BUILT_IN_FERAISEEXCEPT,
BUILT_IN_FESETENV,
BUILT_IN_FESETEXCEPTFLAG,
BUILT_IN_FESETROUND,
BUILT_IN_FETESTEXCEPT,
BUILT_IN_FEUPDATEENV,
BUILT_IN_FLOOR,
BUILT_IN_FLOORF,
BUILT_IN_FLOORL,
BUILT_IN_FLOORF16, BUILT_IN_FLOORF32, BUILT_IN_FLOORF64, BUILT_IN_FLOORF128, BUILT_IN_FLOORF32X, BUILT_IN_FLOORF64X, BUILT_IN_FLOORF128X,
BUILT_IN_FMA,
BUILT_IN_FMAF,
BUILT_IN_FMAL,
BUILT_IN_FMAF16, BUILT_IN_FMAF32, BUILT_IN_FMAF64, BUILT_IN_FMAF128, BUILT_IN_FMAF32X, BUILT_IN_FMAF64X, BUILT_IN_FMAF128X,
BUILT_IN_FMAX,
BUILT_IN_FMAXF,
BUILT_IN_FMAXL,
BUILT_IN_FMAXF16, BUILT_IN_FMAXF32, BUILT_IN_FMAXF64, BUILT_IN_FMAXF128, BUILT_IN_FMAXF32X, BUILT_IN_FMAXF64X, BUILT_IN_FMAXF128X,
BUILT_IN_FMIN,
BUILT_IN_FMINF,
BUILT_IN_FMINL,
BUILT_IN_FMINF16, BUILT_IN_FMINF32, BUILT_IN_FMINF64, BUILT_IN_FMINF128, BUILT_IN_FMINF32X, BUILT_IN_FMINF64X, BUILT_IN_FMINF128X,
BUILT_IN_FMOD,
BUILT_IN_FMODF,
BUILT_IN_FMODL,
BUILT_IN_FREXP,
BUILT_IN_FREXPF,
BUILT_IN_FREXPL,
BUILT_IN_GAMMA,
BUILT_IN_GAMMAF,
BUILT_IN_GAMMAL,
BUILT_IN_GAMMA_R,
BUILT_IN_GAMMAF_R,
BUILT_IN_GAMMAL_R,
BUILT_IN_HUGE_VAL,
BUILT_IN_HUGE_VALF,
BUILT_IN_HUGE_VALL,
BUILT_IN_HUGE_VALF16, BUILT_IN_HUGE_VALF32, BUILT_IN_HUGE_VALF64, BUILT_IN_HUGE_VALF128, BUILT_IN_HUGE_VALF32X, BUILT_IN_HUGE_VALF64X, BUILT_IN_HUGE_VALF128X,
BUILT_IN_HYPOT,
BUILT_IN_HYPOTF,
BUILT_IN_HYPOTL,
BUILT_IN_ICEIL,
BUILT_IN_ICEILF,
BUILT_IN_ICEILL,
BUILT_IN_IFLOOR,
BUILT_IN_IFLOORF,
BUILT_IN_IFLOORL,
BUILT_IN_ILOGB,
BUILT_IN_ILOGBF,
BUILT_IN_ILOGBL,
BUILT_IN_INF,
BUILT_IN_INFF,
BUILT_IN_INFL,
BUILT_IN_INFF16, BUILT_IN_INFF32, BUILT_IN_INFF64, BUILT_IN_INFF128, BUILT_IN_INFF32X, BUILT_IN_INFF64X, BUILT_IN_INFF128X,
BUILT_IN_INFD32,
BUILT_IN_INFD64,
BUILT_IN_INFD128,
BUILT_IN_IRINT,
BUILT_IN_IRINTF,
BUILT_IN_IRINTL,
BUILT_IN_IROUND,
BUILT_IN_IROUNDF,
BUILT_IN_IROUNDL,
BUILT_IN_J0,
BUILT_IN_J0F,
BUILT_IN_J0L,
BUILT_IN_J1,
BUILT_IN_J1F,
BUILT_IN_J1L,
BUILT_IN_JN,
BUILT_IN_JNF,
BUILT_IN_JNL,
BUILT_IN_LCEIL,
BUILT_IN_LCEILF,
BUILT_IN_LCEILL,
BUILT_IN_LDEXP,
BUILT_IN_LDEXPF,
BUILT_IN_LDEXPL,
BUILT_IN_LFLOOR,
BUILT_IN_LFLOORF,
BUILT_IN_LFLOORL,
BUILT_IN_LGAMMA,
BUILT_IN_LGAMMAF,
BUILT_IN_LGAMMAL,
BUILT_IN_LGAMMA_R,
BUILT_IN_LGAMMAF_R,
BUILT_IN_LGAMMAL_R,
BUILT_IN_LLCEIL,
BUILT_IN_LLCEILF,
BUILT_IN_LLCEILL,
BUILT_IN_LLFLOOR,
BUILT_IN_LLFLOORF,
BUILT_IN_LLFLOORL,
BUILT_IN_LLRINT,
BUILT_IN_LLRINTF,
BUILT_IN_LLRINTL,
BUILT_IN_LLROUND,
BUILT_IN_LLROUNDF,
BUILT_IN_LLROUNDL,
BUILT_IN_LOG,
BUILT_IN_LOG10,
BUILT_IN_LOG10F,
BUILT_IN_LOG10L,
BUILT_IN_LOG1P,
BUILT_IN_LOG1PF,
BUILT_IN_LOG1PL,
BUILT_IN_LOG2,
BUILT_IN_LOG2F,
BUILT_IN_LOG2L,
BUILT_IN_LOGB,
BUILT_IN_LOGBF,
BUILT_IN_LOGBL,
BUILT_IN_LOGF,
BUILT_IN_LOGL,
BUILT_IN_LRINT,
BUILT_IN_LRINTF,
BUILT_IN_LRINTL,
BUILT_IN_LROUND,
BUILT_IN_LROUNDF,
BUILT_IN_LROUNDL,
BUILT_IN_MODF,
BUILT_IN_MODFF,
BUILT_IN_MODFL,
BUILT_IN_NAN,
BUILT_IN_NANF,
BUILT_IN_NANL,
BUILT_IN_NANF16, BUILT_IN_NANF32, BUILT_IN_NANF64, BUILT_IN_NANF128, BUILT_IN_NANF32X, BUILT_IN_NANF64X, BUILT_IN_NANF128X,
BUILT_IN_NAND32,
BUILT_IN_NAND64,
BUILT_IN_NAND128,
BUILT_IN_NANS,
BUILT_IN_NANSF,
BUILT_IN_NANSL,
BUILT_IN_NANSF16, BUILT_IN_NANSF32, BUILT_IN_NANSF64, BUILT_IN_NANSF128, BUILT_IN_NANSF32X, BUILT_IN_NANSF64X, BUILT_IN_NANSF128X,
BUILT_IN_NEARBYINT,
BUILT_IN_NEARBYINTF,
BUILT_IN_NEARBYINTL,
BUILT_IN_NEARBYINTF16, BUILT_IN_NEARBYINTF32, BUILT_IN_NEARBYINTF64, BUILT_IN_NEARBYINTF128, BUILT_IN_NEARBYINTF32X, BUILT_IN_NEARBYINTF64X, BUILT_IN_NEARBYINTF128X,
BUILT_IN_NEXTAFTER,
BUILT_IN_NEXTAFTERF,
BUILT_IN_NEXTAFTERL,
BUILT_IN_NEXTTOWARD,
BUILT_IN_NEXTTOWARDF,
BUILT_IN_NEXTTOWARDL,
BUILT_IN_POW,
BUILT_IN_POW10,
BUILT_IN_POW10F,
BUILT_IN_POW10L,
BUILT_IN_POWF,
BUILT_IN_POWI,
BUILT_IN_POWIF,
BUILT_IN_POWIL,
BUILT_IN_POWL,
BUILT_IN_REMAINDER,
BUILT_IN_REMAINDERF,
BUILT_IN_REMAINDERL,
BUILT_IN_REMQUO,
BUILT_IN_REMQUOF,
BUILT_IN_REMQUOL,
BUILT_IN_RINT,
BUILT_IN_RINTF,
BUILT_IN_RINTL,
BUILT_IN_RINTF16, BUILT_IN_RINTF32, BUILT_IN_RINTF64, BUILT_IN_RINTF128, BUILT_IN_RINTF32X, BUILT_IN_RINTF64X, BUILT_IN_RINTF128X,
BUILT_IN_ROUNDEVEN,
BUILT_IN_ROUNDEVENF,
BUILT_IN_ROUNDEVENL,
BUILT_IN_ROUND,
BUILT_IN_ROUNDF,
BUILT_IN_ROUNDL,
BUILT_IN_ROUNDF16, BUILT_IN_ROUNDF32, BUILT_IN_ROUNDF64, BUILT_IN_ROUNDF128, BUILT_IN_ROUNDF32X, BUILT_IN_ROUNDF64X, BUILT_IN_ROUNDF128X,
BUILT_IN_ROUNDEVENF16, BUILT_IN_ROUNDEVENF32, BUILT_IN_ROUNDEVENF64, BUILT_IN_ROUNDEVENF128, BUILT_IN_ROUNDEVENF32X, BUILT_IN_ROUNDEVENF64X, BUILT_IN_ROUNDEVENF128X,
BUILT_IN_SCALB,
BUILT_IN_SCALBF,
BUILT_IN_SCALBL,
BUILT_IN_SCALBLN,
BUILT_IN_SCALBLNF,
BUILT_IN_SCALBLNL,
BUILT_IN_SCALBN,
BUILT_IN_SCALBNF,
BUILT_IN_SCALBNL,
BUILT_IN_SIGNBIT,
BUILT_IN_SIGNBITF,
BUILT_IN_SIGNBITL,
BUILT_IN_SIGNBITD32,
BUILT_IN_SIGNBITD64,
BUILT_IN_SIGNBITD128,
BUILT_IN_SIGNIFICAND,
BUILT_IN_SIGNIFICANDF,
BUILT_IN_SIGNIFICANDL,
BUILT_IN_SIN,
BUILT_IN_SINCOS,
BUILT_IN_SINCOSF,
BUILT_IN_SINCOSL,
BUILT_IN_SINF,
BUILT_IN_SINH,
BUILT_IN_SINHF,
BUILT_IN_SINHL,
BUILT_IN_SINL,
BUILT_IN_SQRT,
BUILT_IN_SQRTF,
BUILT_IN_SQRTL,
BUILT_IN_SQRTF16, BUILT_IN_SQRTF32, BUILT_IN_SQRTF64, BUILT_IN_SQRTF128, BUILT_IN_SQRTF32X, BUILT_IN_SQRTF64X, BUILT_IN_SQRTF128X,
BUILT_IN_TAN,
BUILT_IN_TANF,
BUILT_IN_TANH,
BUILT_IN_TANHF,
BUILT_IN_TANHL,
BUILT_IN_TANL,
BUILT_IN_TGAMMA,
BUILT_IN_TGAMMAF,
BUILT_IN_TGAMMAL,
BUILT_IN_TRUNC,
BUILT_IN_TRUNCF,
BUILT_IN_TRUNCL,
BUILT_IN_TRUNCF16, BUILT_IN_TRUNCF32, BUILT_IN_TRUNCF64, BUILT_IN_TRUNCF128, BUILT_IN_TRUNCF32X, BUILT_IN_TRUNCF64X, BUILT_IN_TRUNCF128X,
BUILT_IN_Y0,
BUILT_IN_Y0F,
BUILT_IN_Y0L,
BUILT_IN_Y1,
BUILT_IN_Y1F,
BUILT_IN_Y1L,
BUILT_IN_YN,
BUILT_IN_YNF,
BUILT_IN_YNL,
BUILT_IN_CABS,
BUILT_IN_CABSF,
BUILT_IN_CABSL,
BUILT_IN_CACOS,
BUILT_IN_CACOSF,
BUILT_IN_CACOSH,
BUILT_IN_CACOSHF,
BUILT_IN_CACOSHL,
BUILT_IN_CACOSL,
BUILT_IN_CARG,
BUILT_IN_CARGF,
BUILT_IN_CARGL,
BUILT_IN_CASIN,
BUILT_IN_CASINF,
BUILT_IN_CASINH,
BUILT_IN_CASINHF,
BUILT_IN_CASINHL,
BUILT_IN_CASINL,
BUILT_IN_CATAN,
BUILT_IN_CATANF,
BUILT_IN_CATANH,
BUILT_IN_CATANHF,
BUILT_IN_CATANHL,
BUILT_IN_CATANL,
BUILT_IN_CCOS,
BUILT_IN_CCOSF,
BUILT_IN_CCOSH,
BUILT_IN_CCOSHF,
BUILT_IN_CCOSHL,
BUILT_IN_CCOSL,
BUILT_IN_CEXP,
BUILT_IN_CEXPF,
BUILT_IN_CEXPL,
BUILT_IN_CEXPI,
BUILT_IN_CEXPIF,
BUILT_IN_CEXPIL,
BUILT_IN_CIMAG,
BUILT_IN_CIMAGF,
BUILT_IN_CIMAGL,
BUILT_IN_CLOG,
BUILT_IN_CLOGF,
BUILT_IN_CLOGL,
BUILT_IN_CLOG10,
BUILT_IN_CLOG10F,
BUILT_IN_CLOG10L,
BUILT_IN_CONJ,
BUILT_IN_CONJF,
BUILT_IN_CONJL,
BUILT_IN_CPOW,
BUILT_IN_CPOWF,
BUILT_IN_CPOWL,
BUILT_IN_CPROJ,
BUILT_IN_CPROJF,
BUILT_IN_CPROJL,
BUILT_IN_CREAL,
BUILT_IN_CREALF,
BUILT_IN_CREALL,
BUILT_IN_CSIN,
BUILT_IN_CSINF,
BUILT_IN_CSINH,
BUILT_IN_CSINHF,
BUILT_IN_CSINHL,
BUILT_IN_CSINL,
BUILT_IN_CSQRT,
BUILT_IN_CSQRTF,
BUILT_IN_CSQRTL,
BUILT_IN_CTAN,
BUILT_IN_CTANF,
BUILT_IN_CTANH,
BUILT_IN_CTANHF,
BUILT_IN_CTANHL,
BUILT_IN_CTANL,
BUILT_IN_BCMP,
BUILT_IN_BCOPY,
BUILT_IN_BZERO,
BUILT_IN_INDEX,
BUILT_IN_MEMCHR,
BUILT_IN_MEMCMP,
BUILT_IN_MEMCPY,
BUILT_IN_MEMMOVE,
BUILT_IN_MEMPCPY,
BUILT_IN_MEMSET,
BUILT_IN_RINDEX,
BUILT_IN_STPCPY,
BUILT_IN_STPNCPY,
BUILT_IN_STRCASECMP,
BUILT_IN_STRCAT,
BUILT_IN_STRCHR,
BUILT_IN_STRCMP,
BUILT_IN_STRCPY,
BUILT_IN_STRCSPN,
BUILT_IN_STRDUP,
BUILT_IN_STRNDUP,
BUILT_IN_STRLEN,
BUILT_IN_STRNCASECMP,
BUILT_IN_STRNCAT,
BUILT_IN_STRNCMP,
BUILT_IN_STRNCPY,
BUILT_IN_STRNLEN,
BUILT_IN_STRPBRK,
BUILT_IN_STRRCHR,
BUILT_IN_STRSPN,
BUILT_IN_STRSTR,
BUILT_IN_FPRINTF,
BUILT_IN_FPRINTF_UNLOCKED,
BUILT_IN_PUTC,
BUILT_IN_PUTC_UNLOCKED,
BUILT_IN_FPUTC,
BUILT_IN_FPUTC_UNLOCKED,
BUILT_IN_FPUTS,
BUILT_IN_FPUTS_UNLOCKED,
BUILT_IN_FSCANF,
BUILT_IN_FWRITE,
BUILT_IN_FWRITE_UNLOCKED,
BUILT_IN_PRINTF,
BUILT_IN_PRINTF_UNLOCKED,
BUILT_IN_PUTCHAR,
BUILT_IN_PUTCHAR_UNLOCKED,
BUILT_IN_PUTS,
BUILT_IN_PUTS_UNLOCKED,
BUILT_IN_SCANF,
BUILT_IN_SNPRINTF,
BUILT_IN_SPRINTF,
BUILT_IN_SSCANF,
BUILT_IN_VFPRINTF,
BUILT_IN_VFSCANF,
BUILT_IN_VPRINTF,
BUILT_IN_VSCANF,
BUILT_IN_VSNPRINTF,
BUILT_IN_VSPRINTF,
BUILT_IN_VSSCANF,
BUILT_IN_ISALNUM,
BUILT_IN_ISALPHA,
BUILT_IN_ISASCII,
BUILT_IN_ISBLANK,
BUILT_IN_ISCNTRL,
BUILT_IN_ISDIGIT,
BUILT_IN_ISGRAPH,
BUILT_IN_ISLOWER,
BUILT_IN_ISPRINT,
BUILT_IN_ISPUNCT,
BUILT_IN_ISSPACE,
BUILT_IN_ISUPPER,
BUILT_IN_ISXDIGIT,
BUILT_IN_TOASCII,
BUILT_IN_TOLOWER,
BUILT_IN_TOUPPER,
BUILT_IN_ISWALNUM,
BUILT_IN_ISWALPHA,
BUILT_IN_ISWBLANK,
BUILT_IN_ISWCNTRL,
BUILT_IN_ISWDIGIT,
BUILT_IN_ISWGRAPH,
BUILT_IN_ISWLOWER,
BUILT_IN_ISWPRINT,
BUILT_IN_ISWPUNCT,
BUILT_IN_ISWSPACE,
BUILT_IN_ISWUPPER,
BUILT_IN_ISWXDIGIT,
BUILT_IN_TOWLOWER,
BUILT_IN_TOWUPPER,
BUILT_IN_ADD_OVERFLOW,
BUILT_IN_SUB_OVERFLOW,
BUILT_IN_MUL_OVERFLOW,
BUILT_IN_ADD_OVERFLOW_P,
BUILT_IN_SUB_OVERFLOW_P,
BUILT_IN_MUL_OVERFLOW_P,
BUILT_IN_SADD_OVERFLOW,
BUILT_IN_SADDL_OVERFLOW,
BUILT_IN_SADDLL_OVERFLOW,
BUILT_IN_SSUB_OVERFLOW,
BUILT_IN_SSUBL_OVERFLOW,
BUILT_IN_SSUBLL_OVERFLOW,
BUILT_IN_SMUL_OVERFLOW,
BUILT_IN_SMULL_OVERFLOW,
BUILT_IN_SMULLL_OVERFLOW,
BUILT_IN_UADD_OVERFLOW,
BUILT_IN_UADDL_OVERFLOW,
BUILT_IN_UADDLL_OVERFLOW,
BUILT_IN_USUB_OVERFLOW,
BUILT_IN_USUBL_OVERFLOW,
BUILT_IN_USUBLL_OVERFLOW,
BUILT_IN_UMUL_OVERFLOW,
BUILT_IN_UMULL_OVERFLOW,
BUILT_IN_UMULLL_OVERFLOW,
BUILT_IN_ABORT,
BUILT_IN_ABS,
BUILT_IN_AGGREGATE_INCOMING_ADDRESS,
BUILT_IN_ALLOCA,
BUILT_IN_APPLY,
BUILT_IN_APPLY_ARGS,
BUILT_IN_BSWAP16,
BUILT_IN_BSWAP32,
BUILT_IN_BSWAP64,
BUILT_IN_BSWAP128,
BUILT_IN_CLEAR_CACHE,
BUILT_IN_CALLOC,
BUILT_IN_CLASSIFY_TYPE,
BUILT_IN_CLZ,
BUILT_IN_CLZIMAX,
BUILT_IN_CLZL,
BUILT_IN_CLZLL,
BUILT_IN_CONSTANT_P,
BUILT_IN_CTZ,
BUILT_IN_CTZIMAX,
BUILT_IN_CTZL,
BUILT_IN_CTZLL,
BUILT_IN_CLRSB,
BUILT_IN_CLRSBIMAX,
BUILT_IN_CLRSBL,
BUILT_IN_CLRSBLL,
BUILT_IN_DCGETTEXT,
BUILT_IN_DGETTEXT,
BUILT_IN_DWARF_CFA,
BUILT_IN_DWARF_SP_COLUMN,
BUILT_IN_EH_RETURN,
BUILT_IN_EH_RETURN_DATA_REGNO,
BUILT_IN_EXECL,
BUILT_IN_EXECLP,
BUILT_IN_EXECLE,
BUILT_IN_EXECV,
BUILT_IN_EXECVP,
BUILT_IN_EXECVE,
BUILT_IN_EXIT,
BUILT_IN_EXPECT,
BUILT_IN_EXPECT_WITH_PROBABILITY,
BUILT_IN_ASSUME_ALIGNED,
BUILT_IN_EXTEND_POINTER,
BUILT_IN_EXTRACT_RETURN_ADDR,
BUILT_IN_FFS,
BUILT_IN_FFSIMAX,
BUILT_IN_FFSL,
BUILT_IN_FFSLL,
BUILT_IN_FORK,
BUILT_IN_FRAME_ADDRESS,
BUILT_IN_FREE,
BUILT_IN_FROB_RETURN_ADDR,
BUILT_IN_GETTEXT,
BUILT_IN_IMAXABS,
BUILT_IN_INIT_DWARF_REG_SIZES,
BUILT_IN_FINITE,
BUILT_IN_FINITEF,
BUILT_IN_FINITEL,
BUILT_IN_FINITED32,
BUILT_IN_FINITED64,
BUILT_IN_FINITED128,
BUILT_IN_FPCLASSIFY,
BUILT_IN_ISFINITE,
BUILT_IN_ISINF_SIGN,
BUILT_IN_ISINF,
BUILT_IN_ISINFF,
BUILT_IN_ISINFL,
BUILT_IN_ISINFD32,
BUILT_IN_ISINFD64,
BUILT_IN_ISINFD128,
BUILT_IN_ISNAN,
BUILT_IN_ISNANF,
BUILT_IN_ISNANL,
BUILT_IN_ISNAND32,
BUILT_IN_ISNAND64,
BUILT_IN_ISNAND128,
BUILT_IN_ISNORMAL,
BUILT_IN_ISGREATER,
BUILT_IN_ISGREATEREQUAL,
BUILT_IN_ISLESS,
BUILT_IN_ISLESSEQUAL,
BUILT_IN_ISLESSGREATER,
BUILT_IN_ISUNORDERED,
BUILT_IN_LABS,
BUILT_IN_LLABS,
BUILT_IN_LONGJMP,
BUILT_IN_MALLOC,
BUILT_IN_NEXT_ARG,
BUILT_IN_PARITY,
BUILT_IN_PARITYIMAX,
BUILT_IN_PARITYL,
BUILT_IN_PARITYLL,
BUILT_IN_POPCOUNT,
BUILT_IN_POPCOUNTIMAX,
BUILT_IN_POPCOUNTL,
BUILT_IN_POPCOUNTLL,
BUILT_IN_POSIX_MEMALIGN,
BUILT_IN_PREFETCH,
BUILT_IN_REALLOC,
BUILT_IN_RETURN,
BUILT_IN_RETURN_ADDRESS,
BUILT_IN_SAVEREGS,
BUILT_IN_SETJMP,
BUILT_IN_STRFMON,
BUILT_IN_STRFTIME,
BUILT_IN_TRAP,
BUILT_IN_UNREACHABLE,
BUILT_IN_UNWIND_INIT,
BUILT_IN_UPDATE_SETJMP_BUF,
BUILT_IN_VA_COPY,
BUILT_IN_VA_END,
BUILT_IN_VA_START,
BUILT_IN_VA_ARG_PACK,
BUILT_IN_VA_ARG_PACK_LEN,
BUILT_IN__EXIT,
BUILT_IN__EXIT2,
BUILT_IN_INIT_TRAMPOLINE,
BUILT_IN_INIT_HEAP_TRAMPOLINE,
BUILT_IN_ADJUST_TRAMPOLINE,
BUILT_IN_INIT_DESCRIPTOR,
BUILT_IN_ADJUST_DESCRIPTOR,
BUILT_IN_NONLOCAL_GOTO,
BUILT_IN_SETJMP_SETUP,
BUILT_IN_SETJMP_RECEIVER,
BUILT_IN_STACK_SAVE,
BUILT_IN_STACK_RESTORE,
BUILT_IN_ALLOCA_WITH_ALIGN,
BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX,
BUILT_IN_MEMCMP_EQ,
BUILT_IN_STRCMP_EQ,
BUILT_IN_STRNCMP_EQ,
BUILT_IN_OBJECT_SIZE,
BUILT_IN_MEMCPY_CHK,
BUILT_IN_MEMMOVE_CHK,
BUILT_IN_MEMPCPY_CHK,
BUILT_IN_MEMSET_CHK,
BUILT_IN_STPCPY_CHK,
BUILT_IN_STPNCPY_CHK,
BUILT_IN_STRCAT_CHK,
BUILT_IN_STRCPY_CHK,
BUILT_IN_STRNCAT_CHK,
BUILT_IN_STRNCPY_CHK,
BUILT_IN_SNPRINTF_CHK,
BUILT_IN_SPRINTF_CHK,
BUILT_IN_VSNPRINTF_CHK,
BUILT_IN_VSPRINTF_CHK,
BUILT_IN_FPRINTF_CHK,
BUILT_IN_PRINTF_CHK,
BUILT_IN_VFPRINTF_CHK,
BUILT_IN_VPRINTF_CHK,
BUILT_IN_PROFILE_FUNC_ENTER,
BUILT_IN_PROFILE_FUNC_EXIT,
BUILT_IN_THREAD_POINTER,
BUILT_IN_SET_THREAD_POINTER,
BUILT_IN_EMUTLS_GET_ADDRESS,
BUILT_IN_EMUTLS_REGISTER_COMMON,
# 1017 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def"
BUILT_IN_SPECULATION_SAFE_VALUE_N,
BUILT_IN_SPECULATION_SAFE_VALUE_PTR,
BUILT_IN_SPECULATION_SAFE_VALUE_1,
BUILT_IN_SPECULATION_SAFE_VALUE_2,
BUILT_IN_SPECULATION_SAFE_VALUE_4,
BUILT_IN_SPECULATION_SAFE_VALUE_8,
BUILT_IN_SPECULATION_SAFE_VALUE_16,
BUILT_IN_UNWIND_RESUME,
BUILT_IN_CXA_END_CLEANUP,
BUILT_IN_EH_POINTER,
BUILT_IN_EH_FILTER,
BUILT_IN_EH_COPY_VALUES,
BUILT_IN_FILE,
BUILT_IN_FUNCTION,
BUILT_IN_LINE,
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/sync-builtins.def" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/sync-builtins.def"
BUILT_IN_SYNC_FETCH_AND_ADD_N,
BUILT_IN_SYNC_FETCH_AND_ADD_1,
BUILT_IN_SYNC_FETCH_AND_ADD_2,
BUILT_IN_SYNC_FETCH_AND_ADD_4,
BUILT_IN_SYNC_FETCH_AND_ADD_8,
BUILT_IN_SYNC_FETCH_AND_ADD_16,
BUILT_IN_SYNC_FETCH_AND_SUB_N,
BUILT_IN_SYNC_FETCH_AND_SUB_1,
BUILT_IN_SYNC_FETCH_AND_SUB_2,
BUILT_IN_SYNC_FETCH_AND_SUB_4,
BUILT_IN_SYNC_FETCH_AND_SUB_8,
BUILT_IN_SYNC_FETCH_AND_SUB_16,
BUILT_IN_SYNC_FETCH_AND_OR_N,
BUILT_IN_SYNC_FETCH_AND_OR_1,
BUILT_IN_SYNC_FETCH_AND_OR_2,
BUILT_IN_SYNC_FETCH_AND_OR_4,
BUILT_IN_SYNC_FETCH_AND_OR_8,
BUILT_IN_SYNC_FETCH_AND_OR_16,
BUILT_IN_SYNC_FETCH_AND_AND_N,
BUILT_IN_SYNC_FETCH_AND_AND_1,
BUILT_IN_SYNC_FETCH_AND_AND_2,
BUILT_IN_SYNC_FETCH_AND_AND_4,
BUILT_IN_SYNC_FETCH_AND_AND_8,
BUILT_IN_SYNC_FETCH_AND_AND_16,
BUILT_IN_SYNC_FETCH_AND_XOR_N,
BUILT_IN_SYNC_FETCH_AND_XOR_1,
BUILT_IN_SYNC_FETCH_AND_XOR_2,
BUILT_IN_SYNC_FETCH_AND_XOR_4,
BUILT_IN_SYNC_FETCH_AND_XOR_8,
BUILT_IN_SYNC_FETCH_AND_XOR_16,
BUILT_IN_SYNC_FETCH_AND_NAND_N,
BUILT_IN_SYNC_FETCH_AND_NAND_1,
BUILT_IN_SYNC_FETCH_AND_NAND_2,
BUILT_IN_SYNC_FETCH_AND_NAND_4,
BUILT_IN_SYNC_FETCH_AND_NAND_8,
BUILT_IN_SYNC_FETCH_AND_NAND_16,
BUILT_IN_SYNC_ADD_AND_FETCH_N,
BUILT_IN_SYNC_ADD_AND_FETCH_1,
BUILT_IN_SYNC_ADD_AND_FETCH_2,
BUILT_IN_SYNC_ADD_AND_FETCH_4,
BUILT_IN_SYNC_ADD_AND_FETCH_8,
BUILT_IN_SYNC_ADD_AND_FETCH_16,
BUILT_IN_SYNC_SUB_AND_FETCH_N,
BUILT_IN_SYNC_SUB_AND_FETCH_1,
BUILT_IN_SYNC_SUB_AND_FETCH_2,
BUILT_IN_SYNC_SUB_AND_FETCH_4,
BUILT_IN_SYNC_SUB_AND_FETCH_8,
BUILT_IN_SYNC_SUB_AND_FETCH_16,
BUILT_IN_SYNC_OR_AND_FETCH_N,
BUILT_IN_SYNC_OR_AND_FETCH_1,
BUILT_IN_SYNC_OR_AND_FETCH_2,
BUILT_IN_SYNC_OR_AND_FETCH_4,
BUILT_IN_SYNC_OR_AND_FETCH_8,
BUILT_IN_SYNC_OR_AND_FETCH_16,
BUILT_IN_SYNC_AND_AND_FETCH_N,
BUILT_IN_SYNC_AND_AND_FETCH_1,
BUILT_IN_SYNC_AND_AND_FETCH_2,
BUILT_IN_SYNC_AND_AND_FETCH_4,
BUILT_IN_SYNC_AND_AND_FETCH_8,
BUILT_IN_SYNC_AND_AND_FETCH_16,
BUILT_IN_SYNC_XOR_AND_FETCH_N,
BUILT_IN_SYNC_XOR_AND_FETCH_1,
BUILT_IN_SYNC_XOR_AND_FETCH_2,
BUILT_IN_SYNC_XOR_AND_FETCH_4,
BUILT_IN_SYNC_XOR_AND_FETCH_8,
BUILT_IN_SYNC_XOR_AND_FETCH_16,
BUILT_IN_SYNC_NAND_AND_FETCH_N,
BUILT_IN_SYNC_NAND_AND_FETCH_1,
BUILT_IN_SYNC_NAND_AND_FETCH_2,
BUILT_IN_SYNC_NAND_AND_FETCH_4,
BUILT_IN_SYNC_NAND_AND_FETCH_8,
BUILT_IN_SYNC_NAND_AND_FETCH_16,
BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N,
BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1,
BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2,
BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4,
BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8,
BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16,
BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N,
BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1,
BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2,
BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4,
BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8,
BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16,
BUILT_IN_SYNC_LOCK_TEST_AND_SET_N,
BUILT_IN_SYNC_LOCK_TEST_AND_SET_1,
BUILT_IN_SYNC_LOCK_TEST_AND_SET_2,
BUILT_IN_SYNC_LOCK_TEST_AND_SET_4,
BUILT_IN_SYNC_LOCK_TEST_AND_SET_8,
BUILT_IN_SYNC_LOCK_TEST_AND_SET_16,
BUILT_IN_SYNC_LOCK_RELEASE_N,
BUILT_IN_SYNC_LOCK_RELEASE_1,
BUILT_IN_SYNC_LOCK_RELEASE_2,
BUILT_IN_SYNC_LOCK_RELEASE_4,
BUILT_IN_SYNC_LOCK_RELEASE_8,
BUILT_IN_SYNC_LOCK_RELEASE_16,
BUILT_IN_SYNC_SYNCHRONIZE,
BUILT_IN_ATOMIC_TEST_AND_SET,
BUILT_IN_ATOMIC_CLEAR,
BUILT_IN_ATOMIC_EXCHANGE,
BUILT_IN_ATOMIC_EXCHANGE_N,
BUILT_IN_ATOMIC_EXCHANGE_1,
BUILT_IN_ATOMIC_EXCHANGE_2,
BUILT_IN_ATOMIC_EXCHANGE_4,
BUILT_IN_ATOMIC_EXCHANGE_8,
BUILT_IN_ATOMIC_EXCHANGE_16,
BUILT_IN_ATOMIC_LOAD,
BUILT_IN_ATOMIC_LOAD_N,
BUILT_IN_ATOMIC_LOAD_1,
BUILT_IN_ATOMIC_LOAD_2,
BUILT_IN_ATOMIC_LOAD_4,
BUILT_IN_ATOMIC_LOAD_8,
BUILT_IN_ATOMIC_LOAD_16,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8,
BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16,
BUILT_IN_ATOMIC_STORE,
BUILT_IN_ATOMIC_STORE_N,
BUILT_IN_ATOMIC_STORE_1,
BUILT_IN_ATOMIC_STORE_2,
BUILT_IN_ATOMIC_STORE_4,
BUILT_IN_ATOMIC_STORE_8,
BUILT_IN_ATOMIC_STORE_16,
BUILT_IN_ATOMIC_ADD_FETCH_N,
BUILT_IN_ATOMIC_ADD_FETCH_1,
BUILT_IN_ATOMIC_ADD_FETCH_2,
BUILT_IN_ATOMIC_ADD_FETCH_4,
BUILT_IN_ATOMIC_ADD_FETCH_8,
BUILT_IN_ATOMIC_ADD_FETCH_16,
BUILT_IN_ATOMIC_SUB_FETCH_N,
BUILT_IN_ATOMIC_SUB_FETCH_1,
BUILT_IN_ATOMIC_SUB_FETCH_2,
BUILT_IN_ATOMIC_SUB_FETCH_4,
BUILT_IN_ATOMIC_SUB_FETCH_8,
BUILT_IN_ATOMIC_SUB_FETCH_16,
BUILT_IN_ATOMIC_AND_FETCH_N,
BUILT_IN_ATOMIC_AND_FETCH_1,
BUILT_IN_ATOMIC_AND_FETCH_2,
BUILT_IN_ATOMIC_AND_FETCH_4,
BUILT_IN_ATOMIC_AND_FETCH_8,
BUILT_IN_ATOMIC_AND_FETCH_16,
BUILT_IN_ATOMIC_NAND_FETCH_N,
BUILT_IN_ATOMIC_NAND_FETCH_1,
BUILT_IN_ATOMIC_NAND_FETCH_2,
BUILT_IN_ATOMIC_NAND_FETCH_4,
BUILT_IN_ATOMIC_NAND_FETCH_8,
BUILT_IN_ATOMIC_NAND_FETCH_16,
BUILT_IN_ATOMIC_XOR_FETCH_N,
BUILT_IN_ATOMIC_XOR_FETCH_1,
BUILT_IN_ATOMIC_XOR_FETCH_2,
BUILT_IN_ATOMIC_XOR_FETCH_4,
BUILT_IN_ATOMIC_XOR_FETCH_8,
BUILT_IN_ATOMIC_XOR_FETCH_16,
BUILT_IN_ATOMIC_OR_FETCH_N,
BUILT_IN_ATOMIC_OR_FETCH_1,
BUILT_IN_ATOMIC_OR_FETCH_2,
BUILT_IN_ATOMIC_OR_FETCH_4,
BUILT_IN_ATOMIC_OR_FETCH_8,
BUILT_IN_ATOMIC_OR_FETCH_16,
BUILT_IN_ATOMIC_FETCH_ADD_N,
BUILT_IN_ATOMIC_FETCH_ADD_1,
BUILT_IN_ATOMIC_FETCH_ADD_2,
BUILT_IN_ATOMIC_FETCH_ADD_4,
BUILT_IN_ATOMIC_FETCH_ADD_8,
BUILT_IN_ATOMIC_FETCH_ADD_16,
BUILT_IN_ATOMIC_FETCH_SUB_N,
BUILT_IN_ATOMIC_FETCH_SUB_1,
BUILT_IN_ATOMIC_FETCH_SUB_2,
BUILT_IN_ATOMIC_FETCH_SUB_4,
BUILT_IN_ATOMIC_FETCH_SUB_8,
BUILT_IN_ATOMIC_FETCH_SUB_16,
BUILT_IN_ATOMIC_FETCH_AND_N,
BUILT_IN_ATOMIC_FETCH_AND_1,
BUILT_IN_ATOMIC_FETCH_AND_2,
BUILT_IN_ATOMIC_FETCH_AND_4,
BUILT_IN_ATOMIC_FETCH_AND_8,
BUILT_IN_ATOMIC_FETCH_AND_16,
BUILT_IN_ATOMIC_FETCH_NAND_N,
BUILT_IN_ATOMIC_FETCH_NAND_1,
BUILT_IN_ATOMIC_FETCH_NAND_2,
BUILT_IN_ATOMIC_FETCH_NAND_4,
BUILT_IN_ATOMIC_FETCH_NAND_8,
BUILT_IN_ATOMIC_FETCH_NAND_16,
BUILT_IN_ATOMIC_FETCH_XOR_N,
BUILT_IN_ATOMIC_FETCH_XOR_1,
BUILT_IN_ATOMIC_FETCH_XOR_2,
BUILT_IN_ATOMIC_FETCH_XOR_4,
BUILT_IN_ATOMIC_FETCH_XOR_8,
BUILT_IN_ATOMIC_FETCH_XOR_16,
BUILT_IN_ATOMIC_FETCH_OR_N,
BUILT_IN_ATOMIC_FETCH_OR_1,
BUILT_IN_ATOMIC_FETCH_OR_2,
BUILT_IN_ATOMIC_FETCH_OR_4,
BUILT_IN_ATOMIC_FETCH_OR_8,
BUILT_IN_ATOMIC_FETCH_OR_16,
BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE,
BUILT_IN_ATOMIC_IS_LOCK_FREE,
BUILT_IN_ATOMIC_THREAD_FENCE,
BUILT_IN_ATOMIC_SIGNAL_FENCE,
BUILT_IN_ATOMIC_FERAISEEXCEPT,
# 1049 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/omp-builtins.def" 1
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/omp-builtins.def"
BUILT_IN_ACC_GET_DEVICE_TYPE,
BUILT_IN_GOACC_DATA_START,
BUILT_IN_GOACC_DATA_END,
BUILT_IN_GOACC_ENTER_EXIT_DATA,
BUILT_IN_GOACC_PARALLEL,
BUILT_IN_GOACC_UPDATE,
BUILT_IN_GOACC_WAIT,
BUILT_IN_ACC_ON_DEVICE,
BUILT_IN_GOACC_PARLEVEL_ID,
BUILT_IN_GOACC_PARLEVEL_SIZE,
BUILT_IN_OMP_GET_THREAD_NUM,
BUILT_IN_OMP_GET_NUM_THREADS,
BUILT_IN_OMP_GET_TEAM_NUM,
BUILT_IN_OMP_GET_NUM_TEAMS,
BUILT_IN_GOMP_ATOMIC_START,
BUILT_IN_GOMP_ATOMIC_END,
BUILT_IN_GOMP_BARRIER,
BUILT_IN_GOMP_BARRIER_CANCEL,
BUILT_IN_GOMP_TASKWAIT,
BUILT_IN_GOMP_TASKWAIT_DEPEND,
BUILT_IN_GOMP_TASKYIELD,
BUILT_IN_GOMP_TASKGROUP_START,
BUILT_IN_GOMP_TASKGROUP_END,
BUILT_IN_GOMP_CANCEL,
BUILT_IN_GOMP_CANCELLATION_POINT,
BUILT_IN_GOMP_CRITICAL_START,
BUILT_IN_GOMP_CRITICAL_END,
BUILT_IN_GOMP_CRITICAL_NAME_START,
BUILT_IN_GOMP_CRITICAL_NAME_END,
BUILT_IN_GOMP_LOOP_STATIC_START,
BUILT_IN_GOMP_LOOP_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_GUIDED_START,
BUILT_IN_GOMP_LOOP_RUNTIME_START,
BUILT_IN_GOMP_LOOP_NONMONOTONIC_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_NONMONOTONIC_GUIDED_START,
BUILT_IN_GOMP_LOOP_NONMONOTONIC_RUNTIME_START,
BUILT_IN_GOMP_LOOP_MAYBE_NONMONOTONIC_RUNTIME_START,
BUILT_IN_GOMP_LOOP_ORDERED_STATIC_START,
BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_START,
BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_START,
BUILT_IN_GOMP_LOOP_DOACROSS_STATIC_START,
BUILT_IN_GOMP_LOOP_DOACROSS_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_DOACROSS_GUIDED_START,
BUILT_IN_GOMP_LOOP_DOACROSS_RUNTIME_START,
BUILT_IN_GOMP_LOOP_START,
BUILT_IN_GOMP_LOOP_ORDERED_START,
BUILT_IN_GOMP_LOOP_DOACROSS_START,
BUILT_IN_GOMP_LOOP_STATIC_NEXT,
BUILT_IN_GOMP_LOOP_DYNAMIC_NEXT,
BUILT_IN_GOMP_LOOP_GUIDED_NEXT,
BUILT_IN_GOMP_LOOP_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_NONMONOTONIC_DYNAMIC_NEXT,
BUILT_IN_GOMP_LOOP_NONMONOTONIC_GUIDED_NEXT,
BUILT_IN_GOMP_LOOP_NONMONOTONIC_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_MAYBE_NONMONOTONIC_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_ORDERED_STATIC_NEXT,
BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_NEXT,
BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_NEXT,
BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_ULL_STATIC_START,
BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_ULL_GUIDED_START,
BUILT_IN_GOMP_LOOP_ULL_RUNTIME_START,
BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_START,
BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_RUNTIME_START,
BUILT_IN_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_START,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_START,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_START,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_START,
BUILT_IN_GOMP_LOOP_ULL_DOACROSS_STATIC_START,
BUILT_IN_GOMP_LOOP_ULL_DOACROSS_DYNAMIC_START,
BUILT_IN_GOMP_LOOP_ULL_DOACROSS_GUIDED_START,
BUILT_IN_GOMP_LOOP_ULL_DOACROSS_RUNTIME_START,
BUILT_IN_GOMP_LOOP_ULL_START,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_START,
BUILT_IN_GOMP_LOOP_ULL_DOACROSS_START,
BUILT_IN_GOMP_LOOP_ULL_STATIC_NEXT,
BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_NEXT,
BUILT_IN_GOMP_LOOP_ULL_GUIDED_NEXT,
BUILT_IN_GOMP_LOOP_ULL_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_NEXT,
BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_NEXT,
BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_NEXT,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT,
BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT,
BUILT_IN_GOMP_PARALLEL_LOOP_STATIC,
BUILT_IN_GOMP_PARALLEL_LOOP_DYNAMIC,
BUILT_IN_GOMP_PARALLEL_LOOP_GUIDED,
BUILT_IN_GOMP_PARALLEL_LOOP_RUNTIME,
BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_DYNAMIC,
BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_GUIDED,
BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_RUNTIME,
BUILT_IN_GOMP_PARALLEL_LOOP_MAYBE_NONMONOTONIC_RUNTIME,
BUILT_IN_GOMP_LOOP_END,
BUILT_IN_GOMP_LOOP_END_CANCEL,
BUILT_IN_GOMP_LOOP_END_NOWAIT,
BUILT_IN_GOMP_ORDERED_START,
BUILT_IN_GOMP_ORDERED_END,
BUILT_IN_GOMP_DOACROSS_POST,
BUILT_IN_GOMP_DOACROSS_WAIT,
BUILT_IN_GOMP_DOACROSS_ULL_POST,
BUILT_IN_GOMP_DOACROSS_ULL_WAIT,
BUILT_IN_GOMP_PARALLEL,
BUILT_IN_GOMP_PARALLEL_REDUCTIONS,
BUILT_IN_GOMP_TASK,
BUILT_IN_GOMP_TASKLOOP,
BUILT_IN_GOMP_TASKLOOP_ULL,
BUILT_IN_GOMP_SECTIONS_START,
BUILT_IN_GOMP_SECTIONS2_START,
BUILT_IN_GOMP_SECTIONS_NEXT,
BUILT_IN_GOMP_PARALLEL_SECTIONS,
BUILT_IN_GOMP_SECTIONS_END,
BUILT_IN_GOMP_SECTIONS_END_CANCEL,
BUILT_IN_GOMP_SECTIONS_END_NOWAIT,
BUILT_IN_GOMP_SINGLE_START,
BUILT_IN_GOMP_SINGLE_COPY_START,
BUILT_IN_GOMP_SINGLE_COPY_END,
BUILT_IN_GOMP_OFFLOAD_REGISTER,
BUILT_IN_GOMP_OFFLOAD_UNREGISTER,
BUILT_IN_GOMP_TARGET,
BUILT_IN_GOMP_TARGET_DATA,
BUILT_IN_GOMP_TARGET_END_DATA,
BUILT_IN_GOMP_TARGET_UPDATE,
BUILT_IN_GOMP_TARGET_ENTER_EXIT_DATA,
BUILT_IN_GOMP_TEAMS,
BUILT_IN_GOMP_TEAMS_REG,
BUILT_IN_GOMP_TASKGROUP_REDUCTION_REGISTER,
BUILT_IN_GOMP_TASKGROUP_REDUCTION_UNREGISTER,
BUILT_IN_GOMP_TASK_REDUCTION_REMAP,
BUILT_IN_GOMP_WORKSHARE_TASK_REDUCTION_UNREGISTER,
BUILT_IN_GOACC_DECLARE,
# 1052 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/gtm-builtins.def" 1
BUILT_IN_TM_START,
BUILT_IN_TM_COMMIT,
BUILT_IN_TM_COMMIT_EH,
BUILT_IN_TM_ABORT,
BUILT_IN_TM_IRREVOCABLE,
BUILT_IN_TM_MEMCPY,
BUILT_IN_TM_MEMCPY_RNWT,
BUILT_IN_TM_MEMCPY_RTWN,
BUILT_IN_TM_MEMMOVE,
BUILT_IN_TM_MEMSET,
BUILT_IN_TM_GETTMCLONE_IRR,
BUILT_IN_TM_GETTMCLONE_SAFE,
BUILT_IN_TM_MALLOC,
BUILT_IN_TM_CALLOC,
BUILT_IN_TM_FREE,
BUILT_IN_TM_LOG_1,
BUILT_IN_TM_LOG_2,
BUILT_IN_TM_LOG_4,
BUILT_IN_TM_LOG_8,
BUILT_IN_TM_LOG_FLOAT,
BUILT_IN_TM_LOG_DOUBLE,
BUILT_IN_TM_LOG_LDOUBLE,
BUILT_IN_TM_LOG,
BUILT_IN_TM_LOG_M64,
BUILT_IN_TM_LOG_M128,
BUILT_IN_TM_LOG_M256,
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/gtm-builtins.def"
BUILT_IN_TM_STORE_1,
BUILT_IN_TM_STORE_WAR_1,
BUILT_IN_TM_STORE_WAW_1,
BUILT_IN_TM_STORE_2,
BUILT_IN_TM_STORE_WAR_2,
BUILT_IN_TM_STORE_WAW_2,
BUILT_IN_TM_STORE_4,
BUILT_IN_TM_STORE_WAR_4,
BUILT_IN_TM_STORE_WAW_4,
BUILT_IN_TM_STORE_8,
BUILT_IN_TM_STORE_WAR_8,
BUILT_IN_TM_STORE_WAW_8,
BUILT_IN_TM_STORE_FLOAT,
BUILT_IN_TM_STORE_WAR_FLOAT,
BUILT_IN_TM_STORE_WAW_FLOAT,
BUILT_IN_TM_STORE_DOUBLE,
BUILT_IN_TM_STORE_WAR_DOUBLE,
BUILT_IN_TM_STORE_WAW_DOUBLE,
BUILT_IN_TM_STORE_M64,
BUILT_IN_TM_STORE_WAR_M64,
BUILT_IN_TM_STORE_WAW_M64,
BUILT_IN_TM_STORE_M128,
BUILT_IN_TM_STORE_WAR_M128,
BUILT_IN_TM_STORE_WAW_M128,
BUILT_IN_TM_STORE_M256,
BUILT_IN_TM_STORE_WAR_M256,
BUILT_IN_TM_STORE_WAW_M256,
BUILT_IN_TM_STORE_LDOUBLE,
BUILT_IN_TM_STORE_WAR_LDOUBLE,
BUILT_IN_TM_STORE_WAW_LDOUBLE,
# 133 "/home/giulianob/gcc_git_gnu/gcc/gcc/gtm-builtins.def"
BUILT_IN_TM_LOAD_1,
BUILT_IN_TM_LOAD_RAR_1,
BUILT_IN_TM_LOAD_RAW_1,
BUILT_IN_TM_LOAD_RFW_1,
BUILT_IN_TM_LOAD_2,
BUILT_IN_TM_LOAD_RAR_2,
BUILT_IN_TM_LOAD_RAW_2,
BUILT_IN_TM_LOAD_RFW_2,
BUILT_IN_TM_LOAD_4,
BUILT_IN_TM_LOAD_RAR_4,
BUILT_IN_TM_LOAD_RAW_4,
BUILT_IN_TM_LOAD_RFW_4,
BUILT_IN_TM_LOAD_8,
BUILT_IN_TM_LOAD_RAR_8,
BUILT_IN_TM_LOAD_RAW_8,
BUILT_IN_TM_LOAD_RFW_8,
BUILT_IN_TM_LOAD_FLOAT,
BUILT_IN_TM_LOAD_RAR_FLOAT,
BUILT_IN_TM_LOAD_RAW_FLOAT,
BUILT_IN_TM_LOAD_RFW_FLOAT,
BUILT_IN_TM_LOAD_DOUBLE,
BUILT_IN_TM_LOAD_RAR_DOUBLE,
BUILT_IN_TM_LOAD_RAW_DOUBLE,
BUILT_IN_TM_LOAD_RFW_DOUBLE,
BUILT_IN_TM_LOAD_M64,
BUILT_IN_TM_LOAD_RAR_M64,
BUILT_IN_TM_LOAD_RAW_M64,
BUILT_IN_TM_LOAD_RFW_M64,
BUILT_IN_TM_LOAD_M128,
BUILT_IN_TM_LOAD_RAR_M128,
BUILT_IN_TM_LOAD_RAW_M128,
BUILT_IN_TM_LOAD_RFW_M128,
BUILT_IN_TM_LOAD_M256,
BUILT_IN_TM_LOAD_RAR_M256,
BUILT_IN_TM_LOAD_RAW_M256,
BUILT_IN_TM_LOAD_RFW_M256,
BUILT_IN_TM_LOAD_LDOUBLE,
BUILT_IN_TM_LOAD_RAR_LDOUBLE,
BUILT_IN_TM_LOAD_RAW_LDOUBLE,
BUILT_IN_TM_LOAD_RFW_LDOUBLE,
# 1055 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/sanitizer.def" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/sanitizer.def"
BEGIN_SANITIZER_BUILTINS,
BUILT_IN_ASAN_INIT,
BUILT_IN_ASAN_VERSION_MISMATCH_CHECK,
BUILT_IN_ASAN_REPORT_LOAD1,
BUILT_IN_ASAN_REPORT_LOAD2,
BUILT_IN_ASAN_REPORT_LOAD4,
BUILT_IN_ASAN_REPORT_LOAD8,
BUILT_IN_ASAN_REPORT_LOAD16,
BUILT_IN_ASAN_REPORT_LOAD_N,
BUILT_IN_ASAN_REPORT_STORE1,
BUILT_IN_ASAN_REPORT_STORE2,
BUILT_IN_ASAN_REPORT_STORE4,
BUILT_IN_ASAN_REPORT_STORE8,
BUILT_IN_ASAN_REPORT_STORE16,
BUILT_IN_ASAN_REPORT_STORE_N,
BUILT_IN_ASAN_REPORT_LOAD1_NOABORT,
BUILT_IN_ASAN_REPORT_LOAD2_NOABORT,
BUILT_IN_ASAN_REPORT_LOAD4_NOABORT,
BUILT_IN_ASAN_REPORT_LOAD8_NOABORT,
BUILT_IN_ASAN_REPORT_LOAD16_NOABORT,
BUILT_IN_ASAN_REPORT_LOAD_N_NOABORT,
BUILT_IN_ASAN_REPORT_STORE1_NOABORT,
BUILT_IN_ASAN_REPORT_STORE2_NOABORT,
BUILT_IN_ASAN_REPORT_STORE4_NOABORT,
BUILT_IN_ASAN_REPORT_STORE8_NOABORT,
BUILT_IN_ASAN_REPORT_STORE16_NOABORT,
BUILT_IN_ASAN_REPORT_STORE_N_NOABORT,
BUILT_IN_ASAN_LOAD1,
BUILT_IN_ASAN_LOAD2,
BUILT_IN_ASAN_LOAD4,
BUILT_IN_ASAN_LOAD8,
BUILT_IN_ASAN_LOAD16,
BUILT_IN_ASAN_LOADN,
BUILT_IN_ASAN_STORE1,
BUILT_IN_ASAN_STORE2,
BUILT_IN_ASAN_STORE4,
BUILT_IN_ASAN_STORE8,
BUILT_IN_ASAN_STORE16,
BUILT_IN_ASAN_STOREN,
BUILT_IN_ASAN_LOAD1_NOABORT,
BUILT_IN_ASAN_LOAD2_NOABORT,
BUILT_IN_ASAN_LOAD4_NOABORT,
BUILT_IN_ASAN_LOAD8_NOABORT,
BUILT_IN_ASAN_LOAD16_NOABORT,
BUILT_IN_ASAN_LOADN_NOABORT,
BUILT_IN_ASAN_STORE1_NOABORT,
BUILT_IN_ASAN_STORE2_NOABORT,
BUILT_IN_ASAN_STORE4_NOABORT,
BUILT_IN_ASAN_STORE8_NOABORT,
BUILT_IN_ASAN_STORE16_NOABORT,
BUILT_IN_ASAN_STOREN_NOABORT,
BUILT_IN_ASAN_REGISTER_GLOBALS,
BUILT_IN_ASAN_UNREGISTER_GLOBALS,
BUILT_IN_ASAN_HANDLE_NO_RETURN,
BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT,
BUILT_IN_ASAN_AFTER_DYNAMIC_INIT,
BUILT_IN_ASAN_POISON_STACK_MEMORY,
BUILT_IN_ASAN_UNPOISON_STACK_MEMORY,
BUILT_IN_ASAN_ALLOCA_POISON,
BUILT_IN_ASAN_ALLOCAS_UNPOISON,
BUILT_IN_ASAN_POINTER_COMPARE,
BUILT_IN_ASAN_POINTER_SUBTRACT,
BUILT_IN_TSAN_INIT,
BUILT_IN_TSAN_FUNC_ENTRY,
BUILT_IN_TSAN_FUNC_EXIT,
BUILT_IN_TSAN_VPTR_UPDATE,
BUILT_IN_TSAN_READ1,
BUILT_IN_TSAN_READ2,
BUILT_IN_TSAN_READ4,
BUILT_IN_TSAN_READ8,
BUILT_IN_TSAN_READ16,
BUILT_IN_TSAN_WRITE1,
BUILT_IN_TSAN_WRITE2,
BUILT_IN_TSAN_WRITE4,
BUILT_IN_TSAN_WRITE8,
BUILT_IN_TSAN_WRITE16,
BUILT_IN_TSAN_READ_RANGE,
BUILT_IN_TSAN_WRITE_RANGE,
BUILT_IN_TSAN_VOLATILE_READ1,
BUILT_IN_TSAN_VOLATILE_READ2,
BUILT_IN_TSAN_VOLATILE_READ4,
BUILT_IN_TSAN_VOLATILE_READ8,
BUILT_IN_TSAN_VOLATILE_READ16,
BUILT_IN_TSAN_VOLATILE_WRITE1,
BUILT_IN_TSAN_VOLATILE_WRITE2,
BUILT_IN_TSAN_VOLATILE_WRITE4,
BUILT_IN_TSAN_VOLATILE_WRITE8,
BUILT_IN_TSAN_VOLATILE_WRITE16,
BUILT_IN_TSAN_ATOMIC8_LOAD,
BUILT_IN_TSAN_ATOMIC16_LOAD,
BUILT_IN_TSAN_ATOMIC32_LOAD,
BUILT_IN_TSAN_ATOMIC64_LOAD,
BUILT_IN_TSAN_ATOMIC128_LOAD,
BUILT_IN_TSAN_ATOMIC8_STORE,
BUILT_IN_TSAN_ATOMIC16_STORE,
BUILT_IN_TSAN_ATOMIC32_STORE,
BUILT_IN_TSAN_ATOMIC64_STORE,
BUILT_IN_TSAN_ATOMIC128_STORE,
BUILT_IN_TSAN_ATOMIC8_EXCHANGE,
BUILT_IN_TSAN_ATOMIC16_EXCHANGE,
BUILT_IN_TSAN_ATOMIC32_EXCHANGE,
BUILT_IN_TSAN_ATOMIC64_EXCHANGE,
BUILT_IN_TSAN_ATOMIC128_EXCHANGE,
BUILT_IN_TSAN_ATOMIC8_FETCH_ADD,
BUILT_IN_TSAN_ATOMIC16_FETCH_ADD,
BUILT_IN_TSAN_ATOMIC32_FETCH_ADD,
BUILT_IN_TSAN_ATOMIC64_FETCH_ADD,
BUILT_IN_TSAN_ATOMIC128_FETCH_ADD,
BUILT_IN_TSAN_ATOMIC8_FETCH_SUB,
BUILT_IN_TSAN_ATOMIC16_FETCH_SUB,
BUILT_IN_TSAN_ATOMIC32_FETCH_SUB,
BUILT_IN_TSAN_ATOMIC64_FETCH_SUB,
BUILT_IN_TSAN_ATOMIC128_FETCH_SUB,
BUILT_IN_TSAN_ATOMIC8_FETCH_AND,
BUILT_IN_TSAN_ATOMIC16_FETCH_AND,
BUILT_IN_TSAN_ATOMIC32_FETCH_AND,
BUILT_IN_TSAN_ATOMIC64_FETCH_AND,
BUILT_IN_TSAN_ATOMIC128_FETCH_AND,
BUILT_IN_TSAN_ATOMIC8_FETCH_OR,
BUILT_IN_TSAN_ATOMIC16_FETCH_OR,
BUILT_IN_TSAN_ATOMIC32_FETCH_OR,
BUILT_IN_TSAN_ATOMIC64_FETCH_OR,
BUILT_IN_TSAN_ATOMIC128_FETCH_OR,
BUILT_IN_TSAN_ATOMIC8_FETCH_XOR,
BUILT_IN_TSAN_ATOMIC16_FETCH_XOR,
BUILT_IN_TSAN_ATOMIC32_FETCH_XOR,
BUILT_IN_TSAN_ATOMIC64_FETCH_XOR,
BUILT_IN_TSAN_ATOMIC128_FETCH_XOR,
BUILT_IN_TSAN_ATOMIC8_FETCH_NAND,
BUILT_IN_TSAN_ATOMIC16_FETCH_NAND,
BUILT_IN_TSAN_ATOMIC32_FETCH_NAND,
BUILT_IN_TSAN_ATOMIC64_FETCH_NAND,
BUILT_IN_TSAN_ATOMIC128_FETCH_NAND,
BUILT_IN_TSAN_ATOMIC8_COMPARE_EXCHANGE_STRONG,
BUILT_IN_TSAN_ATOMIC16_COMPARE_EXCHANGE_STRONG,
BUILT_IN_TSAN_ATOMIC32_COMPARE_EXCHANGE_STRONG,
BUILT_IN_TSAN_ATOMIC64_COMPARE_EXCHANGE_STRONG,
BUILT_IN_TSAN_ATOMIC128_COMPARE_EXCHANGE_STRONG,
BUILT_IN_TSAN_ATOMIC8_COMPARE_EXCHANGE_WEAK,
BUILT_IN_TSAN_ATOMIC16_COMPARE_EXCHANGE_WEAK,
BUILT_IN_TSAN_ATOMIC32_COMPARE_EXCHANGE_WEAK,
BUILT_IN_TSAN_ATOMIC64_COMPARE_EXCHANGE_WEAK,
BUILT_IN_TSAN_ATOMIC128_COMPARE_EXCHANGE_WEAK,
BUILT_IN_TSAN_ATOMIC_THREAD_FENCE,
BUILT_IN_TSAN_ATOMIC_SIGNAL_FENCE,
BUILT_IN_UBSAN_HANDLE_DIVREM_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_SHIFT_OUT_OF_BOUNDS,
BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE,
BUILT_IN_UBSAN_HANDLE_MISSING_RETURN,
BUILT_IN_UBSAN_HANDLE_VLA_BOUND_NOT_POSITIVE,
BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_V1,
BUILT_IN_UBSAN_HANDLE_ADD_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_SUB_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_MUL_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_NEGATE_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_LOAD_INVALID_VALUE,
BUILT_IN_UBSAN_HANDLE_POINTER_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_DIVREM_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_SHIFT_OUT_OF_BOUNDS_ABORT,
BUILT_IN_UBSAN_HANDLE_VLA_BOUND_NOT_POSITIVE_ABORT,
BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_V1_ABORT,
BUILT_IN_UBSAN_HANDLE_ADD_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_SUB_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_MUL_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_NEGATE_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_LOAD_INVALID_VALUE_ABORT,
BUILT_IN_UBSAN_HANDLE_POINTER_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_FLOAT_CAST_OVERFLOW,
BUILT_IN_UBSAN_HANDLE_FLOAT_CAST_OVERFLOW_ABORT,
BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS,
BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS_ABORT,
BUILT_IN_UBSAN_HANDLE_NONNULL_ARG,
BUILT_IN_UBSAN_HANDLE_NONNULL_ARG_ABORT,
BUILT_IN_UBSAN_HANDLE_NONNULL_RETURN_V1,
BUILT_IN_UBSAN_HANDLE_NONNULL_RETURN_V1_ABORT,
BUILT_IN_UBSAN_HANDLE_INVALID_BUILTIN,
BUILT_IN_UBSAN_HANDLE_INVALID_BUILTIN_ABORT,
BUILT_IN_UBSAN_HANDLE_DYNAMIC_TYPE_CACHE_MISS,
BUILT_IN_UBSAN_HANDLE_DYNAMIC_TYPE_CACHE_MISS_ABORT,
BUILT_IN_SANITIZER_COV_TRACE_PC,
BUILT_IN_SANITIZER_COV_TRACE_CMP1,
BUILT_IN_SANITIZER_COV_TRACE_CMP2,
BUILT_IN_SANITIZER_COV_TRACE_CMP4,
BUILT_IN_SANITIZER_COV_TRACE_CMP8,
BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP1,
BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP2,
BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP4,
BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP8,
BUILT_IN_SANITIZER_COV_TRACE_CMPF,
BUILT_IN_SANITIZER_COV_TRACE_CMPD,
BUILT_IN_SANITIZER_COV_TRACE_SWITCH,
END_SANITIZER_BUILTINS,
# 1058 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/coroutine-builtins.def" 1
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/coroutine-builtins.def"
BEGIN_COROUTINE_BUILTINS,
BUILT_IN_CORO_PROMISE,
BUILT_IN_CORO_RESUME,
BUILT_IN_CORO_DESTROY,
BUILT_IN_CORO_DONE,
END_COROUTINE_BUILTINS,
# 1061 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1103 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def" 1
# 38 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def"
BUILT_IN_HSAIL_WORKITEMABSID,
BUILT_IN_HSAIL_GRIDSIZE,
BUILT_IN_HSAIL_WORKITEMFLATABSID_U32,
BUILT_IN_HSAIL_WORKITEMFLATABSID_U64,
BUILT_IN_HSAIL_WORKITEMFLATID,
BUILT_IN_HSAIL_WORKITEMID,
BUILT_IN_HSAIL_WORKGROUPID,
BUILT_IN_HSAIL_CURRENTWORKITEMFLATID,
BUILT_IN_HSAIL_WORKITEMABSID_U64,
BUILT_IN_HSAIL_PACKETID,
BUILT_IN_HSAIL_PACKETCOMPLETIONSIG_SIG64,
BUILT_IN_HSAIL_PACKETCOMPLETIONSIG_SIG32,
BUILT_IN_HSAIL_CURRENTWORKGROUPSIZE,
BUILT_IN_HSAIL_WORKGROUPSIZE,
BUILT_IN_HSAIL_DIM,
BUILT_IN_HSAIL_GRIDGROUPS,
BUILT_IN_HSAIL_BITEXTRACT_S32,
BUILT_IN_HSAIL_BITEXTRACT_U32,
BUILT_IN_HSAIL_BITEXTRACT_S64,
BUILT_IN_HSAIL_BITEXTRACT_U64,
BUILT_IN_HSAIL_BITINSERT_U32,
BUILT_IN_HSAIL_BITINSERT_U64,
BUILT_IN_HSAIL_BITMASK_B32,
BUILT_IN_HSAIL_BITMASK_B64,
BUILT_IN_HSAIL_BITREV_B32,
BUILT_IN_HSAIL_BITREV_B64,
BUILT_IN_HSAIL_BITSELECT_B32,
BUILT_IN_HSAIL_BITSELECT_U64,
BUILT_IN_HSAIL_FIRSTBIT_U32,
BUILT_IN_HSAIL_FIRSTBIT_S32,
BUILT_IN_HSAIL_FIRSTBIT_U64,
BUILT_IN_HSAIL_FIRSTBIT_S64,
BUILT_IN_HSAIL_LASTBIT_U32,
BUILT_IN_HSAIL_LASTBIT_U64,
BUILT_IN_HSAIL_BORROW_U32,
BUILT_IN_HSAIL_BORROW_U64,
BUILT_IN_HSAIL_CARRY_U32,
BUILT_IN_HSAIL_CARRY_U64,
BUILT_IN_HSAIL_REM_S32,
BUILT_IN_HSAIL_REM_S64,
BUILT_IN_HSAIL_MIN_F32,
BUILT_IN_HSAIL_MAX_F32,
BUILT_IN_HSAIL_MIN_F64,
BUILT_IN_HSAIL_MAX_F64,
BUILT_IN_HSAIL_CLASS_F32,
BUILT_IN_HSAIL_CLASS_F64,
BUILT_IN_HSAIL_CLASS_F32_F16,
BUILT_IN_HSAIL_FRACT_F32,
BUILT_IN_HSAIL_FRACT_F64,
BUILT_IN_HSAIL_BARRIER,
BUILT_IN_HSAIL_INITFBAR,
BUILT_IN_HSAIL_JOINFBAR,
BUILT_IN_HSAIL_WAITFBAR,
BUILT_IN_HSAIL_ARRIVEFBAR,
BUILT_IN_HSAIL_LEAVEFBAR,
BUILT_IN_HSAIL_RELEASEFBAR,
BUILT_IN_HSAIL_BITALIGN,
BUILT_IN_HSAIL_BYTEALIGN,
BUILT_IN_HSAIL_LERP,
BUILT_IN_HSAIL_PACKCVT,
BUILT_IN_HSAIL_UNPACKCVT,
BUILT_IN_HSAIL_SAD_U16X2,
BUILT_IN_HSAIL_SAD_U32,
BUILT_IN_HSAIL_SAD_U8X4,
BUILT_IN_HSAIL_SADHI_U8X4,
BUILT_IN_HSAIL_CLOCK,
BUILT_IN_HSAIL_CUID,
BUILT_IN_HSAIL_MAXCUID,
BUILT_IN_HSAIL_DEBUGTRAP,
BUILT_IN_HSAIL_GROUPBASEPTR,
BUILT_IN_HSAIL_KERNARGBASEPTR_U64,
BUILT_IN_HSAIL_KERNARGBASEPTR_U32,
BUILT_IN_HSAIL_ALLOCA,
BUILT_IN_HSAIL_LDQUEUEWRITEINDEX,
BUILT_IN_HSAIL_LDQUEUEREADINDEX,
BUILT_IN_HSAIL_STQUEUEWRITEINDEX,
BUILT_IN_HSAIL_STQUEUEREADINDEX,
BUILT_IN_HSAIL_ADDQUEUEWRITEINDEX,
BUILT_IN_HSAIL_CASQUEUEWRITEINDEX,
BUILT_IN_HSAIL_SEGMENTP_GLOBAL,
BUILT_IN_HSAIL_SEGMENTP_GROUP,
BUILT_IN_HSAIL_SEGMENTP_PRIVATE,
# 392 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def"
BUILT_IN_HSAIL_ATOMIC_MIN_S32,
BUILT_IN_HSAIL_ATOMIC_MIN_S64,
BUILT_IN_HSAIL_ATOMIC_MIN_U32,
BUILT_IN_HSAIL_ATOMIC_MIN_U64,
BUILT_IN_HSAIL_ATOMIC_MAX_S32,
BUILT_IN_HSAIL_ATOMIC_MAX_S64,
BUILT_IN_HSAIL_ATOMIC_MAX_U32,
BUILT_IN_HSAIL_ATOMIC_MAX_U64,
BUILT_IN_HSAIL_ATOMIC_WRAPDEC_U32,
BUILT_IN_HSAIL_ATOMIC_WRAPDEC_U64,
BUILT_IN_HSAIL_ATOMIC_WRAPINC_U32,
BUILT_IN_HSAIL_ATOMIC_WRAPINC_U64,
# 449 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def"
BUILT_IN_HSAIL_SAT_ADD_U64,
BUILT_IN_HSAIL_SAT_ADD_S64,
BUILT_IN_HSAIL_SAT_ADD_U32,
BUILT_IN_HSAIL_SAT_ADD_S32,
BUILT_IN_HSAIL_SAT_ADD_U16,
BUILT_IN_HSAIL_SAT_ADD_S16,
BUILT_IN_HSAIL_SAT_ADD_U8,
BUILT_IN_HSAIL_SAT_ADD_S8,
BUILT_IN_HSAIL_SAT_SUB_U64,
BUILT_IN_HSAIL_SAT_SUB_S64,
BUILT_IN_HSAIL_SAT_SUB_U32,
BUILT_IN_HSAIL_SAT_SUB_S32,
BUILT_IN_HSAIL_SAT_SUB_U16,
BUILT_IN_HSAIL_SAT_SUB_S16,
BUILT_IN_HSAIL_SAT_SUB_U8,
BUILT_IN_HSAIL_SAT_SUB_S8,
BUILT_IN_HSAIL_SAT_MUL_U64,
BUILT_IN_HSAIL_SAT_MUL_S64,
BUILT_IN_HSAIL_SAT_MUL_U32,
BUILT_IN_HSAIL_SAT_MUL_S32,
BUILT_IN_HSAIL_SAT_MUL_U16,
BUILT_IN_HSAIL_SAT_MUL_S16,
BUILT_IN_HSAIL_SAT_MUL_U8,
BUILT_IN_HSAIL_SAT_MUL_S8,
BUILT_IN_HSAIL_FTZ_F32_F16,
BUILT_IN_HSAIL_FTZ_F32,
BUILT_IN_HSAIL_FTZ_F64,
BUILT_IN_HSAIL_PUSH_FRAME,
BUILT_IN_HSAIL_POP_FRAME,
BUILT_IN_HSAIL_SETWORKITEMID,
BUILT_IN_HSAIL_LAUNCH_WG_FUNC,
BUILT_IN_HSAIL_LAUNCH_KERNEL,
BUILT_IN_HSAIL_F32_TO_F16,
BUILT_IN_HSAIL_F16_TO_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U8_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S8_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U16_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S16_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U32_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S32_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U64_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S64_F32,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U8_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S8_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U16_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S16_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U32_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S32_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_U64_F64,
BUILT_IN_HSAIL_CVT_ZEROI_SAT_S64_F64,
# 1104 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 168 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
BUILT_IN_COMPLEX_MUL_MIN,
BUILT_IN_COMPLEX_MUL_MAX
= BUILT_IN_COMPLEX_MUL_MIN
+ MAX_MODE_COMPLEX_FLOAT
- MIN_MODE_COMPLEX_FLOAT,
BUILT_IN_COMPLEX_DIV_MIN,
BUILT_IN_COMPLEX_DIV_MAX
= BUILT_IN_COMPLEX_DIV_MIN
+ MAX_MODE_COMPLEX_FLOAT
- MIN_MODE_COMPLEX_FLOAT,
END_BUILTINS
};
enum internal_fn {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/internal-fn.def" 1
# 123 "/home/giulianob/gcc_git_gnu/gcc/gcc/internal-fn.def"
IFN_MASK_LOAD,
IFN_LOAD_LANES,
IFN_MASK_LOAD_LANES,
IFN_GATHER_LOAD,
IFN_MASK_GATHER_LOAD,
IFN_LEN_LOAD,
IFN_SCATTER_STORE,
IFN_MASK_SCATTER_STORE,
IFN_MASK_STORE,
IFN_STORE_LANES,
IFN_MASK_STORE_LANES,
IFN_VCOND,
IFN_VCONDU,
IFN_VCONDEQ,
IFN_VCOND_MASK,
IFN_LEN_STORE,
IFN_WHILE_ULT,
IFN_CHECK_RAW_PTRS,
IFN_CHECK_WAR_PTRS,
IFN_VEC_SHL_INSERT,
IFN_DIV_POW2,
IFN_FMS,
IFN_FNMA,
IFN_FNMS,
IFN_AVG_FLOOR,
IFN_AVG_CEIL,
IFN_MULHS,
IFN_MULHRS,
IFN_COND_ADD,
IFN_COND_SUB,
IFN_COND_MUL,
IFN_COND_DIV,
IFN_COND_MOD,
IFN_COND_RDIV,
IFN_COND_MIN,
IFN_COND_MAX,
IFN_COND_AND,
IFN_COND_IOR,
IFN_COND_XOR,
IFN_COND_SHL,
IFN_COND_SHR,
IFN_COND_FMA,
IFN_COND_FMS,
IFN_COND_FNMA,
IFN_COND_FNMS,
IFN_RSQRT,
IFN_REDUC_PLUS,
IFN_REDUC_MAX,
IFN_REDUC_MIN,
IFN_REDUC_AND,
IFN_REDUC_IOR,
IFN_REDUC_XOR,
IFN_EXTRACT_LAST,
IFN_FOLD_EXTRACT_LAST,
IFN_FOLD_LEFT_PLUS,
IFN_MASK_FOLD_LEFT_PLUS,
IFN_ACOS,
IFN_ACOSH,
IFN_ASIN,
IFN_ASINH,
IFN_ATAN,
IFN_ATANH,
IFN_COS,
IFN_COSH,
IFN_EXP,
IFN_EXP10,
IFN_EXP2,
IFN_EXPM1,
IFN_LOG,
IFN_LOG10,
IFN_LOG1P,
IFN_LOG2,
IFN_LOGB,
IFN_SIGNBIT,
IFN_SIGNIFICAND,
IFN_SIN,
IFN_SINH,
IFN_SQRT,
IFN_TAN,
IFN_TANH,
IFN_CEIL,
IFN_FLOOR,
IFN_NEARBYINT,
IFN_RINT,
IFN_ROUND,
IFN_ROUNDEVEN,
IFN_TRUNC,
IFN_ATAN2,
IFN_COPYSIGN,
IFN_FMOD,
IFN_HYPOT,
IFN_POW,
IFN_REMAINDER,
IFN_SCALB,
IFN_FMIN,
IFN_FMAX,
IFN_XORSIGN,
IFN_LDEXP,
IFN_FMA,
IFN_CLRSB,
IFN_CLZ,
IFN_CTZ,
IFN_FFS,
IFN_PARITY,
IFN_POPCOUNT,
IFN_GOMP_USE_SIMT,
IFN_GOMP_SIMT_ENTER,
IFN_GOMP_SIMT_ENTER_ALLOC,
IFN_GOMP_SIMT_EXIT,
IFN_GOMP_SIMT_LANE,
IFN_GOMP_SIMT_VF,
IFN_GOMP_SIMT_LAST_LANE,
IFN_GOMP_SIMT_ORDERED_PRED,
IFN_GOMP_SIMT_VOTE_ANY,
IFN_GOMP_SIMT_XCHG_BFLY,
IFN_GOMP_SIMT_XCHG_IDX,
IFN_GOMP_SIMD_LANE,
IFN_GOMP_SIMD_VF,
IFN_GOMP_SIMD_LAST_LANE,
IFN_GOMP_SIMD_ORDERED_START,
IFN_GOMP_SIMD_ORDERED_END,
IFN_LOOP_VECTORIZED,
IFN_LOOP_DIST_ALIAS,
IFN_ANNOTATE,
IFN_UBSAN_NULL,
IFN_UBSAN_BOUNDS,
IFN_UBSAN_VPTR,
IFN_UBSAN_CHECK_ADD,
IFN_UBSAN_CHECK_SUB,
IFN_UBSAN_CHECK_MUL,
IFN_UBSAN_PTR,
IFN_UBSAN_OBJECT_SIZE,
IFN_ABNORMAL_DISPATCHER,
IFN_BUILTIN_EXPECT,
IFN_ASAN_CHECK,
IFN_ASAN_MARK,
IFN_ASAN_POISON,
IFN_ASAN_POISON_USE,
IFN_ADD_OVERFLOW,
IFN_SUB_OVERFLOW,
IFN_MUL_OVERFLOW,
IFN_TSAN_FUNC_EXIT,
IFN_VA_ARG,
IFN_VEC_CONVERT,
IFN_UNIQUE,
IFN_PHI,
IFN_GOACC_DIM_SIZE,
IFN_GOACC_DIM_POS,
IFN_GOACC_LOOP,
IFN_GOACC_REDUCTION,
IFN_GOACC_TILE,
IFN_SET_EDOM,
IFN_ATOMIC_BIT_TEST_AND_SET,
IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT,
IFN_ATOMIC_BIT_TEST_AND_RESET,
IFN_ATOMIC_COMPARE_EXCHANGE,
IFN_FALLTHROUGH,
IFN_LAUNDER,
IFN_DIVMOD,
IFN_CO_ACTOR,
IFN_CO_YIELD,
IFN_CO_SUSPN,
IFN_CO_FRAME,
IFN_NOP,
# 190 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
IFN_LAST
};
enum combined_fn {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 1
# 282 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def"
CFN_BUILT_IN_NONE = int (BUILT_IN_NONE),
CFN_BUILT_IN_ACOS = int (BUILT_IN_ACOS),
CFN_BUILT_IN_ACOSF = int (BUILT_IN_ACOSF),
CFN_BUILT_IN_ACOSH = int (BUILT_IN_ACOSH),
CFN_BUILT_IN_ACOSHF = int (BUILT_IN_ACOSHF),
CFN_BUILT_IN_ACOSHL = int (BUILT_IN_ACOSHL),
CFN_BUILT_IN_ACOSL = int (BUILT_IN_ACOSL),
CFN_BUILT_IN_ALIGNED_ALLOC = int (BUILT_IN_ALIGNED_ALLOC),
CFN_BUILT_IN_ASIN = int (BUILT_IN_ASIN),
CFN_BUILT_IN_ASINF = int (BUILT_IN_ASINF),
CFN_BUILT_IN_ASINH = int (BUILT_IN_ASINH),
CFN_BUILT_IN_ASINHF = int (BUILT_IN_ASINHF),
CFN_BUILT_IN_ASINHL = int (BUILT_IN_ASINHL),
CFN_BUILT_IN_ASINL = int (BUILT_IN_ASINL),
CFN_BUILT_IN_ATAN = int (BUILT_IN_ATAN),
CFN_BUILT_IN_ATAN2 = int (BUILT_IN_ATAN2),
CFN_BUILT_IN_ATAN2F = int (BUILT_IN_ATAN2F),
CFN_BUILT_IN_ATAN2L = int (BUILT_IN_ATAN2L),
CFN_BUILT_IN_ATANF = int (BUILT_IN_ATANF),
CFN_BUILT_IN_ATANH = int (BUILT_IN_ATANH),
CFN_BUILT_IN_ATANHF = int (BUILT_IN_ATANHF),
CFN_BUILT_IN_ATANHL = int (BUILT_IN_ATANHL),
CFN_BUILT_IN_ATANL = int (BUILT_IN_ATANL),
CFN_BUILT_IN_CBRT = int (BUILT_IN_CBRT),
CFN_BUILT_IN_CBRTF = int (BUILT_IN_CBRTF),
CFN_BUILT_IN_CBRTL = int (BUILT_IN_CBRTL),
CFN_BUILT_IN_CEIL = int (BUILT_IN_CEIL),
CFN_BUILT_IN_CEILF = int (BUILT_IN_CEILF),
CFN_BUILT_IN_CEILL = int (BUILT_IN_CEILL),
CFN_BUILT_IN_CEILF16 = int (BUILT_IN_CEILF16), CFN_BUILT_IN_CEILF32 = int (BUILT_IN_CEILF32), CFN_BUILT_IN_CEILF64 = int (BUILT_IN_CEILF64), CFN_BUILT_IN_CEILF128 = int (BUILT_IN_CEILF128), CFN_BUILT_IN_CEILF32X = int (BUILT_IN_CEILF32X), CFN_BUILT_IN_CEILF64X = int (BUILT_IN_CEILF64X), CFN_BUILT_IN_CEILF128X = int (BUILT_IN_CEILF128X),
CFN_BUILT_IN_COPYSIGN = int (BUILT_IN_COPYSIGN),
CFN_BUILT_IN_COPYSIGNF = int (BUILT_IN_COPYSIGNF),
CFN_BUILT_IN_COPYSIGNL = int (BUILT_IN_COPYSIGNL),
CFN_BUILT_IN_COPYSIGNF16 = int (BUILT_IN_COPYSIGNF16), CFN_BUILT_IN_COPYSIGNF32 = int (BUILT_IN_COPYSIGNF32), CFN_BUILT_IN_COPYSIGNF64 = int (BUILT_IN_COPYSIGNF64), CFN_BUILT_IN_COPYSIGNF128 = int (BUILT_IN_COPYSIGNF128), CFN_BUILT_IN_COPYSIGNF32X = int (BUILT_IN_COPYSIGNF32X), CFN_BUILT_IN_COPYSIGNF64X = int (BUILT_IN_COPYSIGNF64X), CFN_BUILT_IN_COPYSIGNF128X = int (BUILT_IN_COPYSIGNF128X),
CFN_BUILT_IN_COS = int (BUILT_IN_COS),
CFN_BUILT_IN_COSF = int (BUILT_IN_COSF),
CFN_BUILT_IN_COSH = int (BUILT_IN_COSH),
CFN_BUILT_IN_COSHF = int (BUILT_IN_COSHF),
CFN_BUILT_IN_COSHL = int (BUILT_IN_COSHL),
CFN_BUILT_IN_COSL = int (BUILT_IN_COSL),
CFN_BUILT_IN_DREM = int (BUILT_IN_DREM),
CFN_BUILT_IN_DREMF = int (BUILT_IN_DREMF),
CFN_BUILT_IN_DREML = int (BUILT_IN_DREML),
CFN_BUILT_IN_ERF = int (BUILT_IN_ERF),
CFN_BUILT_IN_ERFC = int (BUILT_IN_ERFC),
CFN_BUILT_IN_ERFCF = int (BUILT_IN_ERFCF),
CFN_BUILT_IN_ERFCL = int (BUILT_IN_ERFCL),
CFN_BUILT_IN_ERFF = int (BUILT_IN_ERFF),
CFN_BUILT_IN_ERFL = int (BUILT_IN_ERFL),
CFN_BUILT_IN_EXP = int (BUILT_IN_EXP),
CFN_BUILT_IN_EXP10 = int (BUILT_IN_EXP10),
CFN_BUILT_IN_EXP10F = int (BUILT_IN_EXP10F),
CFN_BUILT_IN_EXP10L = int (BUILT_IN_EXP10L),
CFN_BUILT_IN_EXP2 = int (BUILT_IN_EXP2),
CFN_BUILT_IN_EXP2F = int (BUILT_IN_EXP2F),
CFN_BUILT_IN_EXP2L = int (BUILT_IN_EXP2L),
CFN_BUILT_IN_EXPF = int (BUILT_IN_EXPF),
CFN_BUILT_IN_EXPL = int (BUILT_IN_EXPL),
CFN_BUILT_IN_EXPM1 = int (BUILT_IN_EXPM1),
CFN_BUILT_IN_EXPM1F = int (BUILT_IN_EXPM1F),
CFN_BUILT_IN_EXPM1L = int (BUILT_IN_EXPM1L),
CFN_BUILT_IN_FABS = int (BUILT_IN_FABS),
CFN_BUILT_IN_FABSF = int (BUILT_IN_FABSF),
CFN_BUILT_IN_FABSL = int (BUILT_IN_FABSL),
CFN_BUILT_IN_FABSF16 = int (BUILT_IN_FABSF16), CFN_BUILT_IN_FABSF32 = int (BUILT_IN_FABSF32), CFN_BUILT_IN_FABSF64 = int (BUILT_IN_FABSF64), CFN_BUILT_IN_FABSF128 = int (BUILT_IN_FABSF128), CFN_BUILT_IN_FABSF32X = int (BUILT_IN_FABSF32X), CFN_BUILT_IN_FABSF64X = int (BUILT_IN_FABSF64X), CFN_BUILT_IN_FABSF128X = int (BUILT_IN_FABSF128X),
CFN_BUILT_IN_FABSD32 = int (BUILT_IN_FABSD32),
CFN_BUILT_IN_FABSD64 = int (BUILT_IN_FABSD64),
CFN_BUILT_IN_FABSD128 = int (BUILT_IN_FABSD128),
CFN_BUILT_IN_FDIM = int (BUILT_IN_FDIM),
CFN_BUILT_IN_FDIMF = int (BUILT_IN_FDIMF),
CFN_BUILT_IN_FDIML = int (BUILT_IN_FDIML),
CFN_BUILT_IN_FECLEAREXCEPT = int (BUILT_IN_FECLEAREXCEPT),
CFN_BUILT_IN_FEGETENV = int (BUILT_IN_FEGETENV),
CFN_BUILT_IN_FEGETEXCEPTFLAG = int (BUILT_IN_FEGETEXCEPTFLAG),
CFN_BUILT_IN_FEGETROUND = int (BUILT_IN_FEGETROUND),
CFN_BUILT_IN_FEHOLDEXCEPT = int (BUILT_IN_FEHOLDEXCEPT),
CFN_BUILT_IN_FERAISEEXCEPT = int (BUILT_IN_FERAISEEXCEPT),
CFN_BUILT_IN_FESETENV = int (BUILT_IN_FESETENV),
CFN_BUILT_IN_FESETEXCEPTFLAG = int (BUILT_IN_FESETEXCEPTFLAG),
CFN_BUILT_IN_FESETROUND = int (BUILT_IN_FESETROUND),
CFN_BUILT_IN_FETESTEXCEPT = int (BUILT_IN_FETESTEXCEPT),
CFN_BUILT_IN_FEUPDATEENV = int (BUILT_IN_FEUPDATEENV),
CFN_BUILT_IN_FLOOR = int (BUILT_IN_FLOOR),
CFN_BUILT_IN_FLOORF = int (BUILT_IN_FLOORF),
CFN_BUILT_IN_FLOORL = int (BUILT_IN_FLOORL),
CFN_BUILT_IN_FLOORF16 = int (BUILT_IN_FLOORF16), CFN_BUILT_IN_FLOORF32 = int (BUILT_IN_FLOORF32), CFN_BUILT_IN_FLOORF64 = int (BUILT_IN_FLOORF64), CFN_BUILT_IN_FLOORF128 = int (BUILT_IN_FLOORF128), CFN_BUILT_IN_FLOORF32X = int (BUILT_IN_FLOORF32X), CFN_BUILT_IN_FLOORF64X = int (BUILT_IN_FLOORF64X), CFN_BUILT_IN_FLOORF128X = int (BUILT_IN_FLOORF128X),
CFN_BUILT_IN_FMA = int (BUILT_IN_FMA),
CFN_BUILT_IN_FMAF = int (BUILT_IN_FMAF),
CFN_BUILT_IN_FMAL = int (BUILT_IN_FMAL),
CFN_BUILT_IN_FMAF16 = int (BUILT_IN_FMAF16), CFN_BUILT_IN_FMAF32 = int (BUILT_IN_FMAF32), CFN_BUILT_IN_FMAF64 = int (BUILT_IN_FMAF64), CFN_BUILT_IN_FMAF128 = int (BUILT_IN_FMAF128), CFN_BUILT_IN_FMAF32X = int (BUILT_IN_FMAF32X), CFN_BUILT_IN_FMAF64X = int (BUILT_IN_FMAF64X), CFN_BUILT_IN_FMAF128X = int (BUILT_IN_FMAF128X),
CFN_BUILT_IN_FMAX = int (BUILT_IN_FMAX),
CFN_BUILT_IN_FMAXF = int (BUILT_IN_FMAXF),
CFN_BUILT_IN_FMAXL = int (BUILT_IN_FMAXL),
CFN_BUILT_IN_FMAXF16 = int (BUILT_IN_FMAXF16), CFN_BUILT_IN_FMAXF32 = int (BUILT_IN_FMAXF32), CFN_BUILT_IN_FMAXF64 = int (BUILT_IN_FMAXF64), CFN_BUILT_IN_FMAXF128 = int (BUILT_IN_FMAXF128), CFN_BUILT_IN_FMAXF32X = int (BUILT_IN_FMAXF32X), CFN_BUILT_IN_FMAXF64X = int (BUILT_IN_FMAXF64X), CFN_BUILT_IN_FMAXF128X = int (BUILT_IN_FMAXF128X),
CFN_BUILT_IN_FMIN = int (BUILT_IN_FMIN),
CFN_BUILT_IN_FMINF = int (BUILT_IN_FMINF),
CFN_BUILT_IN_FMINL = int (BUILT_IN_FMINL),
CFN_BUILT_IN_FMINF16 = int (BUILT_IN_FMINF16), CFN_BUILT_IN_FMINF32 = int (BUILT_IN_FMINF32), CFN_BUILT_IN_FMINF64 = int (BUILT_IN_FMINF64), CFN_BUILT_IN_FMINF128 = int (BUILT_IN_FMINF128), CFN_BUILT_IN_FMINF32X = int (BUILT_IN_FMINF32X), CFN_BUILT_IN_FMINF64X = int (BUILT_IN_FMINF64X), CFN_BUILT_IN_FMINF128X = int (BUILT_IN_FMINF128X),
CFN_BUILT_IN_FMOD = int (BUILT_IN_FMOD),
CFN_BUILT_IN_FMODF = int (BUILT_IN_FMODF),
CFN_BUILT_IN_FMODL = int (BUILT_IN_FMODL),
CFN_BUILT_IN_FREXP = int (BUILT_IN_FREXP),
CFN_BUILT_IN_FREXPF = int (BUILT_IN_FREXPF),
CFN_BUILT_IN_FREXPL = int (BUILT_IN_FREXPL),
CFN_BUILT_IN_GAMMA = int (BUILT_IN_GAMMA),
CFN_BUILT_IN_GAMMAF = int (BUILT_IN_GAMMAF),
CFN_BUILT_IN_GAMMAL = int (BUILT_IN_GAMMAL),
CFN_BUILT_IN_GAMMA_R = int (BUILT_IN_GAMMA_R),
CFN_BUILT_IN_GAMMAF_R = int (BUILT_IN_GAMMAF_R),
CFN_BUILT_IN_GAMMAL_R = int (BUILT_IN_GAMMAL_R),
CFN_BUILT_IN_HUGE_VAL = int (BUILT_IN_HUGE_VAL),
CFN_BUILT_IN_HUGE_VALF = int (BUILT_IN_HUGE_VALF),
CFN_BUILT_IN_HUGE_VALL = int (BUILT_IN_HUGE_VALL),
CFN_BUILT_IN_HUGE_VALF16 = int (BUILT_IN_HUGE_VALF16), CFN_BUILT_IN_HUGE_VALF32 = int (BUILT_IN_HUGE_VALF32), CFN_BUILT_IN_HUGE_VALF64 = int (BUILT_IN_HUGE_VALF64), CFN_BUILT_IN_HUGE_VALF128 = int (BUILT_IN_HUGE_VALF128), CFN_BUILT_IN_HUGE_VALF32X = int (BUILT_IN_HUGE_VALF32X), CFN_BUILT_IN_HUGE_VALF64X = int (BUILT_IN_HUGE_VALF64X), CFN_BUILT_IN_HUGE_VALF128X = int (BUILT_IN_HUGE_VALF128X),
CFN_BUILT_IN_HYPOT = int (BUILT_IN_HYPOT),
CFN_BUILT_IN_HYPOTF = int (BUILT_IN_HYPOTF),
CFN_BUILT_IN_HYPOTL = int (BUILT_IN_HYPOTL),
CFN_BUILT_IN_ICEIL = int (BUILT_IN_ICEIL),
CFN_BUILT_IN_ICEILF = int (BUILT_IN_ICEILF),
CFN_BUILT_IN_ICEILL = int (BUILT_IN_ICEILL),
CFN_BUILT_IN_IFLOOR = int (BUILT_IN_IFLOOR),
CFN_BUILT_IN_IFLOORF = int (BUILT_IN_IFLOORF),
CFN_BUILT_IN_IFLOORL = int (BUILT_IN_IFLOORL),
CFN_BUILT_IN_ILOGB = int (BUILT_IN_ILOGB),
CFN_BUILT_IN_ILOGBF = int (BUILT_IN_ILOGBF),
CFN_BUILT_IN_ILOGBL = int (BUILT_IN_ILOGBL),
CFN_BUILT_IN_INF = int (BUILT_IN_INF),
CFN_BUILT_IN_INFF = int (BUILT_IN_INFF),
CFN_BUILT_IN_INFL = int (BUILT_IN_INFL),
CFN_BUILT_IN_INFF16 = int (BUILT_IN_INFF16), CFN_BUILT_IN_INFF32 = int (BUILT_IN_INFF32), CFN_BUILT_IN_INFF64 = int (BUILT_IN_INFF64), CFN_BUILT_IN_INFF128 = int (BUILT_IN_INFF128), CFN_BUILT_IN_INFF32X = int (BUILT_IN_INFF32X), CFN_BUILT_IN_INFF64X = int (BUILT_IN_INFF64X), CFN_BUILT_IN_INFF128X = int (BUILT_IN_INFF128X),
CFN_BUILT_IN_INFD32 = int (BUILT_IN_INFD32),
CFN_BUILT_IN_INFD64 = int (BUILT_IN_INFD64),
CFN_BUILT_IN_INFD128 = int (BUILT_IN_INFD128),
CFN_BUILT_IN_IRINT = int (BUILT_IN_IRINT),
CFN_BUILT_IN_IRINTF = int (BUILT_IN_IRINTF),
CFN_BUILT_IN_IRINTL = int (BUILT_IN_IRINTL),
CFN_BUILT_IN_IROUND = int (BUILT_IN_IROUND),
CFN_BUILT_IN_IROUNDF = int (BUILT_IN_IROUNDF),
CFN_BUILT_IN_IROUNDL = int (BUILT_IN_IROUNDL),
CFN_BUILT_IN_J0 = int (BUILT_IN_J0),
CFN_BUILT_IN_J0F = int (BUILT_IN_J0F),
CFN_BUILT_IN_J0L = int (BUILT_IN_J0L),
CFN_BUILT_IN_J1 = int (BUILT_IN_J1),
CFN_BUILT_IN_J1F = int (BUILT_IN_J1F),
CFN_BUILT_IN_J1L = int (BUILT_IN_J1L),
CFN_BUILT_IN_JN = int (BUILT_IN_JN),
CFN_BUILT_IN_JNF = int (BUILT_IN_JNF),
CFN_BUILT_IN_JNL = int (BUILT_IN_JNL),
CFN_BUILT_IN_LCEIL = int (BUILT_IN_LCEIL),
CFN_BUILT_IN_LCEILF = int (BUILT_IN_LCEILF),
CFN_BUILT_IN_LCEILL = int (BUILT_IN_LCEILL),
CFN_BUILT_IN_LDEXP = int (BUILT_IN_LDEXP),
CFN_BUILT_IN_LDEXPF = int (BUILT_IN_LDEXPF),
CFN_BUILT_IN_LDEXPL = int (BUILT_IN_LDEXPL),
CFN_BUILT_IN_LFLOOR = int (BUILT_IN_LFLOOR),
CFN_BUILT_IN_LFLOORF = int (BUILT_IN_LFLOORF),
CFN_BUILT_IN_LFLOORL = int (BUILT_IN_LFLOORL),
CFN_BUILT_IN_LGAMMA = int (BUILT_IN_LGAMMA),
CFN_BUILT_IN_LGAMMAF = int (BUILT_IN_LGAMMAF),
CFN_BUILT_IN_LGAMMAL = int (BUILT_IN_LGAMMAL),
CFN_BUILT_IN_LGAMMA_R = int (BUILT_IN_LGAMMA_R),
CFN_BUILT_IN_LGAMMAF_R = int (BUILT_IN_LGAMMAF_R),
CFN_BUILT_IN_LGAMMAL_R = int (BUILT_IN_LGAMMAL_R),
CFN_BUILT_IN_LLCEIL = int (BUILT_IN_LLCEIL),
CFN_BUILT_IN_LLCEILF = int (BUILT_IN_LLCEILF),
CFN_BUILT_IN_LLCEILL = int (BUILT_IN_LLCEILL),
CFN_BUILT_IN_LLFLOOR = int (BUILT_IN_LLFLOOR),
CFN_BUILT_IN_LLFLOORF = int (BUILT_IN_LLFLOORF),
CFN_BUILT_IN_LLFLOORL = int (BUILT_IN_LLFLOORL),
CFN_BUILT_IN_LLRINT = int (BUILT_IN_LLRINT),
CFN_BUILT_IN_LLRINTF = int (BUILT_IN_LLRINTF),
CFN_BUILT_IN_LLRINTL = int (BUILT_IN_LLRINTL),
CFN_BUILT_IN_LLROUND = int (BUILT_IN_LLROUND),
CFN_BUILT_IN_LLROUNDF = int (BUILT_IN_LLROUNDF),
CFN_BUILT_IN_LLROUNDL = int (BUILT_IN_LLROUNDL),
CFN_BUILT_IN_LOG = int (BUILT_IN_LOG),
CFN_BUILT_IN_LOG10 = int (BUILT_IN_LOG10),
CFN_BUILT_IN_LOG10F = int (BUILT_IN_LOG10F),
CFN_BUILT_IN_LOG10L = int (BUILT_IN_LOG10L),
CFN_BUILT_IN_LOG1P = int (BUILT_IN_LOG1P),
CFN_BUILT_IN_LOG1PF = int (BUILT_IN_LOG1PF),
CFN_BUILT_IN_LOG1PL = int (BUILT_IN_LOG1PL),
CFN_BUILT_IN_LOG2 = int (BUILT_IN_LOG2),
CFN_BUILT_IN_LOG2F = int (BUILT_IN_LOG2F),
CFN_BUILT_IN_LOG2L = int (BUILT_IN_LOG2L),
CFN_BUILT_IN_LOGB = int (BUILT_IN_LOGB),
CFN_BUILT_IN_LOGBF = int (BUILT_IN_LOGBF),
CFN_BUILT_IN_LOGBL = int (BUILT_IN_LOGBL),
CFN_BUILT_IN_LOGF = int (BUILT_IN_LOGF),
CFN_BUILT_IN_LOGL = int (BUILT_IN_LOGL),
CFN_BUILT_IN_LRINT = int (BUILT_IN_LRINT),
CFN_BUILT_IN_LRINTF = int (BUILT_IN_LRINTF),
CFN_BUILT_IN_LRINTL = int (BUILT_IN_LRINTL),
CFN_BUILT_IN_LROUND = int (BUILT_IN_LROUND),
CFN_BUILT_IN_LROUNDF = int (BUILT_IN_LROUNDF),
CFN_BUILT_IN_LROUNDL = int (BUILT_IN_LROUNDL),
CFN_BUILT_IN_MODF = int (BUILT_IN_MODF),
CFN_BUILT_IN_MODFF = int (BUILT_IN_MODFF),
CFN_BUILT_IN_MODFL = int (BUILT_IN_MODFL),
CFN_BUILT_IN_NAN = int (BUILT_IN_NAN),
CFN_BUILT_IN_NANF = int (BUILT_IN_NANF),
CFN_BUILT_IN_NANL = int (BUILT_IN_NANL),
CFN_BUILT_IN_NANF16 = int (BUILT_IN_NANF16), CFN_BUILT_IN_NANF32 = int (BUILT_IN_NANF32), CFN_BUILT_IN_NANF64 = int (BUILT_IN_NANF64), CFN_BUILT_IN_NANF128 = int (BUILT_IN_NANF128), CFN_BUILT_IN_NANF32X = int (BUILT_IN_NANF32X), CFN_BUILT_IN_NANF64X = int (BUILT_IN_NANF64X), CFN_BUILT_IN_NANF128X = int (BUILT_IN_NANF128X),
CFN_BUILT_IN_NAND32 = int (BUILT_IN_NAND32),
CFN_BUILT_IN_NAND64 = int (BUILT_IN_NAND64),
CFN_BUILT_IN_NAND128 = int (BUILT_IN_NAND128),
CFN_BUILT_IN_NANS = int (BUILT_IN_NANS),
CFN_BUILT_IN_NANSF = int (BUILT_IN_NANSF),
CFN_BUILT_IN_NANSL = int (BUILT_IN_NANSL),
CFN_BUILT_IN_NANSF16 = int (BUILT_IN_NANSF16), CFN_BUILT_IN_NANSF32 = int (BUILT_IN_NANSF32), CFN_BUILT_IN_NANSF64 = int (BUILT_IN_NANSF64), CFN_BUILT_IN_NANSF128 = int (BUILT_IN_NANSF128), CFN_BUILT_IN_NANSF32X = int (BUILT_IN_NANSF32X), CFN_BUILT_IN_NANSF64X = int (BUILT_IN_NANSF64X), CFN_BUILT_IN_NANSF128X = int (BUILT_IN_NANSF128X),
CFN_BUILT_IN_NEARBYINT = int (BUILT_IN_NEARBYINT),
CFN_BUILT_IN_NEARBYINTF = int (BUILT_IN_NEARBYINTF),
CFN_BUILT_IN_NEARBYINTL = int (BUILT_IN_NEARBYINTL),
CFN_BUILT_IN_NEARBYINTF16 = int (BUILT_IN_NEARBYINTF16), CFN_BUILT_IN_NEARBYINTF32 = int (BUILT_IN_NEARBYINTF32), CFN_BUILT_IN_NEARBYINTF64 = int (BUILT_IN_NEARBYINTF64), CFN_BUILT_IN_NEARBYINTF128 = int (BUILT_IN_NEARBYINTF128), CFN_BUILT_IN_NEARBYINTF32X = int (BUILT_IN_NEARBYINTF32X), CFN_BUILT_IN_NEARBYINTF64X = int (BUILT_IN_NEARBYINTF64X), CFN_BUILT_IN_NEARBYINTF128X = int (BUILT_IN_NEARBYINTF128X),
CFN_BUILT_IN_NEXTAFTER = int (BUILT_IN_NEXTAFTER),
CFN_BUILT_IN_NEXTAFTERF = int (BUILT_IN_NEXTAFTERF),
CFN_BUILT_IN_NEXTAFTERL = int (BUILT_IN_NEXTAFTERL),
CFN_BUILT_IN_NEXTTOWARD = int (BUILT_IN_NEXTTOWARD),
CFN_BUILT_IN_NEXTTOWARDF = int (BUILT_IN_NEXTTOWARDF),
CFN_BUILT_IN_NEXTTOWARDL = int (BUILT_IN_NEXTTOWARDL),
CFN_BUILT_IN_POW = int (BUILT_IN_POW),
CFN_BUILT_IN_POW10 = int (BUILT_IN_POW10),
CFN_BUILT_IN_POW10F = int (BUILT_IN_POW10F),
CFN_BUILT_IN_POW10L = int (BUILT_IN_POW10L),
CFN_BUILT_IN_POWF = int (BUILT_IN_POWF),
CFN_BUILT_IN_POWI = int (BUILT_IN_POWI),
CFN_BUILT_IN_POWIF = int (BUILT_IN_POWIF),
CFN_BUILT_IN_POWIL = int (BUILT_IN_POWIL),
CFN_BUILT_IN_POWL = int (BUILT_IN_POWL),
CFN_BUILT_IN_REMAINDER = int (BUILT_IN_REMAINDER),
CFN_BUILT_IN_REMAINDERF = int (BUILT_IN_REMAINDERF),
CFN_BUILT_IN_REMAINDERL = int (BUILT_IN_REMAINDERL),
CFN_BUILT_IN_REMQUO = int (BUILT_IN_REMQUO),
CFN_BUILT_IN_REMQUOF = int (BUILT_IN_REMQUOF),
CFN_BUILT_IN_REMQUOL = int (BUILT_IN_REMQUOL),
CFN_BUILT_IN_RINT = int (BUILT_IN_RINT),
CFN_BUILT_IN_RINTF = int (BUILT_IN_RINTF),
CFN_BUILT_IN_RINTL = int (BUILT_IN_RINTL),
CFN_BUILT_IN_RINTF16 = int (BUILT_IN_RINTF16), CFN_BUILT_IN_RINTF32 = int (BUILT_IN_RINTF32), CFN_BUILT_IN_RINTF64 = int (BUILT_IN_RINTF64), CFN_BUILT_IN_RINTF128 = int (BUILT_IN_RINTF128), CFN_BUILT_IN_RINTF32X = int (BUILT_IN_RINTF32X), CFN_BUILT_IN_RINTF64X = int (BUILT_IN_RINTF64X), CFN_BUILT_IN_RINTF128X = int (BUILT_IN_RINTF128X),
CFN_BUILT_IN_ROUNDEVEN = int (BUILT_IN_ROUNDEVEN),
CFN_BUILT_IN_ROUNDEVENF = int (BUILT_IN_ROUNDEVENF),
CFN_BUILT_IN_ROUNDEVENL = int (BUILT_IN_ROUNDEVENL),
CFN_BUILT_IN_ROUND = int (BUILT_IN_ROUND),
CFN_BUILT_IN_ROUNDF = int (BUILT_IN_ROUNDF),
CFN_BUILT_IN_ROUNDL = int (BUILT_IN_ROUNDL),
CFN_BUILT_IN_ROUNDF16 = int (BUILT_IN_ROUNDF16), CFN_BUILT_IN_ROUNDF32 = int (BUILT_IN_ROUNDF32), CFN_BUILT_IN_ROUNDF64 = int (BUILT_IN_ROUNDF64), CFN_BUILT_IN_ROUNDF128 = int (BUILT_IN_ROUNDF128), CFN_BUILT_IN_ROUNDF32X = int (BUILT_IN_ROUNDF32X), CFN_BUILT_IN_ROUNDF64X = int (BUILT_IN_ROUNDF64X), CFN_BUILT_IN_ROUNDF128X = int (BUILT_IN_ROUNDF128X),
CFN_BUILT_IN_ROUNDEVENF16 = int (BUILT_IN_ROUNDEVENF16), CFN_BUILT_IN_ROUNDEVENF32 = int (BUILT_IN_ROUNDEVENF32), CFN_BUILT_IN_ROUNDEVENF64 = int (BUILT_IN_ROUNDEVENF64), CFN_BUILT_IN_ROUNDEVENF128 = int (BUILT_IN_ROUNDEVENF128), CFN_BUILT_IN_ROUNDEVENF32X = int (BUILT_IN_ROUNDEVENF32X), CFN_BUILT_IN_ROUNDEVENF64X = int (BUILT_IN_ROUNDEVENF64X), CFN_BUILT_IN_ROUNDEVENF128X = int (BUILT_IN_ROUNDEVENF128X),
CFN_BUILT_IN_SCALB = int (BUILT_IN_SCALB),
CFN_BUILT_IN_SCALBF = int (BUILT_IN_SCALBF),
CFN_BUILT_IN_SCALBL = int (BUILT_IN_SCALBL),
CFN_BUILT_IN_SCALBLN = int (BUILT_IN_SCALBLN),
CFN_BUILT_IN_SCALBLNF = int (BUILT_IN_SCALBLNF),
CFN_BUILT_IN_SCALBLNL = int (BUILT_IN_SCALBLNL),
CFN_BUILT_IN_SCALBN = int (BUILT_IN_SCALBN),
CFN_BUILT_IN_SCALBNF = int (BUILT_IN_SCALBNF),
CFN_BUILT_IN_SCALBNL = int (BUILT_IN_SCALBNL),
CFN_BUILT_IN_SIGNBIT = int (BUILT_IN_SIGNBIT),
CFN_BUILT_IN_SIGNBITF = int (BUILT_IN_SIGNBITF),
CFN_BUILT_IN_SIGNBITL = int (BUILT_IN_SIGNBITL),
CFN_BUILT_IN_SIGNBITD32 = int (BUILT_IN_SIGNBITD32),
CFN_BUILT_IN_SIGNBITD64 = int (BUILT_IN_SIGNBITD64),
CFN_BUILT_IN_SIGNBITD128 = int (BUILT_IN_SIGNBITD128),
CFN_BUILT_IN_SIGNIFICAND = int (BUILT_IN_SIGNIFICAND),
CFN_BUILT_IN_SIGNIFICANDF = int (BUILT_IN_SIGNIFICANDF),
CFN_BUILT_IN_SIGNIFICANDL = int (BUILT_IN_SIGNIFICANDL),
CFN_BUILT_IN_SIN = int (BUILT_IN_SIN),
CFN_BUILT_IN_SINCOS = int (BUILT_IN_SINCOS),
CFN_BUILT_IN_SINCOSF = int (BUILT_IN_SINCOSF),
CFN_BUILT_IN_SINCOSL = int (BUILT_IN_SINCOSL),
CFN_BUILT_IN_SINF = int (BUILT_IN_SINF),
CFN_BUILT_IN_SINH = int (BUILT_IN_SINH),
CFN_BUILT_IN_SINHF = int (BUILT_IN_SINHF),
CFN_BUILT_IN_SINHL = int (BUILT_IN_SINHL),
CFN_BUILT_IN_SINL = int (BUILT_IN_SINL),
CFN_BUILT_IN_SQRT = int (BUILT_IN_SQRT),
CFN_BUILT_IN_SQRTF = int (BUILT_IN_SQRTF),
CFN_BUILT_IN_SQRTL = int (BUILT_IN_SQRTL),
CFN_BUILT_IN_SQRTF16 = int (BUILT_IN_SQRTF16), CFN_BUILT_IN_SQRTF32 = int (BUILT_IN_SQRTF32), CFN_BUILT_IN_SQRTF64 = int (BUILT_IN_SQRTF64), CFN_BUILT_IN_SQRTF128 = int (BUILT_IN_SQRTF128), CFN_BUILT_IN_SQRTF32X = int (BUILT_IN_SQRTF32X), CFN_BUILT_IN_SQRTF64X = int (BUILT_IN_SQRTF64X), CFN_BUILT_IN_SQRTF128X = int (BUILT_IN_SQRTF128X),
CFN_BUILT_IN_TAN = int (BUILT_IN_TAN),
CFN_BUILT_IN_TANF = int (BUILT_IN_TANF),
CFN_BUILT_IN_TANH = int (BUILT_IN_TANH),
CFN_BUILT_IN_TANHF = int (BUILT_IN_TANHF),
CFN_BUILT_IN_TANHL = int (BUILT_IN_TANHL),
CFN_BUILT_IN_TANL = int (BUILT_IN_TANL),
CFN_BUILT_IN_TGAMMA = int (BUILT_IN_TGAMMA),
CFN_BUILT_IN_TGAMMAF = int (BUILT_IN_TGAMMAF),
CFN_BUILT_IN_TGAMMAL = int (BUILT_IN_TGAMMAL),
CFN_BUILT_IN_TRUNC = int (BUILT_IN_TRUNC),
CFN_BUILT_IN_TRUNCF = int (BUILT_IN_TRUNCF),
CFN_BUILT_IN_TRUNCL = int (BUILT_IN_TRUNCL),
CFN_BUILT_IN_TRUNCF16 = int (BUILT_IN_TRUNCF16), CFN_BUILT_IN_TRUNCF32 = int (BUILT_IN_TRUNCF32), CFN_BUILT_IN_TRUNCF64 = int (BUILT_IN_TRUNCF64), CFN_BUILT_IN_TRUNCF128 = int (BUILT_IN_TRUNCF128), CFN_BUILT_IN_TRUNCF32X = int (BUILT_IN_TRUNCF32X), CFN_BUILT_IN_TRUNCF64X = int (BUILT_IN_TRUNCF64X), CFN_BUILT_IN_TRUNCF128X = int (BUILT_IN_TRUNCF128X),
CFN_BUILT_IN_Y0 = int (BUILT_IN_Y0),
CFN_BUILT_IN_Y0F = int (BUILT_IN_Y0F),
CFN_BUILT_IN_Y0L = int (BUILT_IN_Y0L),
CFN_BUILT_IN_Y1 = int (BUILT_IN_Y1),
CFN_BUILT_IN_Y1F = int (BUILT_IN_Y1F),
CFN_BUILT_IN_Y1L = int (BUILT_IN_Y1L),
CFN_BUILT_IN_YN = int (BUILT_IN_YN),
CFN_BUILT_IN_YNF = int (BUILT_IN_YNF),
CFN_BUILT_IN_YNL = int (BUILT_IN_YNL),
CFN_BUILT_IN_CABS = int (BUILT_IN_CABS),
CFN_BUILT_IN_CABSF = int (BUILT_IN_CABSF),
CFN_BUILT_IN_CABSL = int (BUILT_IN_CABSL),
CFN_BUILT_IN_CACOS = int (BUILT_IN_CACOS),
CFN_BUILT_IN_CACOSF = int (BUILT_IN_CACOSF),
CFN_BUILT_IN_CACOSH = int (BUILT_IN_CACOSH),
CFN_BUILT_IN_CACOSHF = int (BUILT_IN_CACOSHF),
CFN_BUILT_IN_CACOSHL = int (BUILT_IN_CACOSHL),
CFN_BUILT_IN_CACOSL = int (BUILT_IN_CACOSL),
CFN_BUILT_IN_CARG = int (BUILT_IN_CARG),
CFN_BUILT_IN_CARGF = int (BUILT_IN_CARGF),
CFN_BUILT_IN_CARGL = int (BUILT_IN_CARGL),
CFN_BUILT_IN_CASIN = int (BUILT_IN_CASIN),
CFN_BUILT_IN_CASINF = int (BUILT_IN_CASINF),
CFN_BUILT_IN_CASINH = int (BUILT_IN_CASINH),
CFN_BUILT_IN_CASINHF = int (BUILT_IN_CASINHF),
CFN_BUILT_IN_CASINHL = int (BUILT_IN_CASINHL),
CFN_BUILT_IN_CASINL = int (BUILT_IN_CASINL),
CFN_BUILT_IN_CATAN = int (BUILT_IN_CATAN),
CFN_BUILT_IN_CATANF = int (BUILT_IN_CATANF),
CFN_BUILT_IN_CATANH = int (BUILT_IN_CATANH),
CFN_BUILT_IN_CATANHF = int (BUILT_IN_CATANHF),
CFN_BUILT_IN_CATANHL = int (BUILT_IN_CATANHL),
CFN_BUILT_IN_CATANL = int (BUILT_IN_CATANL),
CFN_BUILT_IN_CCOS = int (BUILT_IN_CCOS),
CFN_BUILT_IN_CCOSF = int (BUILT_IN_CCOSF),
CFN_BUILT_IN_CCOSH = int (BUILT_IN_CCOSH),
CFN_BUILT_IN_CCOSHF = int (BUILT_IN_CCOSHF),
CFN_BUILT_IN_CCOSHL = int (BUILT_IN_CCOSHL),
CFN_BUILT_IN_CCOSL = int (BUILT_IN_CCOSL),
CFN_BUILT_IN_CEXP = int (BUILT_IN_CEXP),
CFN_BUILT_IN_CEXPF = int (BUILT_IN_CEXPF),
CFN_BUILT_IN_CEXPL = int (BUILT_IN_CEXPL),
CFN_BUILT_IN_CEXPI = int (BUILT_IN_CEXPI),
CFN_BUILT_IN_CEXPIF = int (BUILT_IN_CEXPIF),
CFN_BUILT_IN_CEXPIL = int (BUILT_IN_CEXPIL),
CFN_BUILT_IN_CIMAG = int (BUILT_IN_CIMAG),
CFN_BUILT_IN_CIMAGF = int (BUILT_IN_CIMAGF),
CFN_BUILT_IN_CIMAGL = int (BUILT_IN_CIMAGL),
CFN_BUILT_IN_CLOG = int (BUILT_IN_CLOG),
CFN_BUILT_IN_CLOGF = int (BUILT_IN_CLOGF),
CFN_BUILT_IN_CLOGL = int (BUILT_IN_CLOGL),
CFN_BUILT_IN_CLOG10 = int (BUILT_IN_CLOG10),
CFN_BUILT_IN_CLOG10F = int (BUILT_IN_CLOG10F),
CFN_BUILT_IN_CLOG10L = int (BUILT_IN_CLOG10L),
CFN_BUILT_IN_CONJ = int (BUILT_IN_CONJ),
CFN_BUILT_IN_CONJF = int (BUILT_IN_CONJF),
CFN_BUILT_IN_CONJL = int (BUILT_IN_CONJL),
CFN_BUILT_IN_CPOW = int (BUILT_IN_CPOW),
CFN_BUILT_IN_CPOWF = int (BUILT_IN_CPOWF),
CFN_BUILT_IN_CPOWL = int (BUILT_IN_CPOWL),
CFN_BUILT_IN_CPROJ = int (BUILT_IN_CPROJ),
CFN_BUILT_IN_CPROJF = int (BUILT_IN_CPROJF),
CFN_BUILT_IN_CPROJL = int (BUILT_IN_CPROJL),
CFN_BUILT_IN_CREAL = int (BUILT_IN_CREAL),
CFN_BUILT_IN_CREALF = int (BUILT_IN_CREALF),
CFN_BUILT_IN_CREALL = int (BUILT_IN_CREALL),
CFN_BUILT_IN_CSIN = int (BUILT_IN_CSIN),
CFN_BUILT_IN_CSINF = int (BUILT_IN_CSINF),
CFN_BUILT_IN_CSINH = int (BUILT_IN_CSINH),
CFN_BUILT_IN_CSINHF = int (BUILT_IN_CSINHF),
CFN_BUILT_IN_CSINHL = int (BUILT_IN_CSINHL),
CFN_BUILT_IN_CSINL = int (BUILT_IN_CSINL),
CFN_BUILT_IN_CSQRT = int (BUILT_IN_CSQRT),
CFN_BUILT_IN_CSQRTF = int (BUILT_IN_CSQRTF),
CFN_BUILT_IN_CSQRTL = int (BUILT_IN_CSQRTL),
CFN_BUILT_IN_CTAN = int (BUILT_IN_CTAN),
CFN_BUILT_IN_CTANF = int (BUILT_IN_CTANF),
CFN_BUILT_IN_CTANH = int (BUILT_IN_CTANH),
CFN_BUILT_IN_CTANHF = int (BUILT_IN_CTANHF),
CFN_BUILT_IN_CTANHL = int (BUILT_IN_CTANHL),
CFN_BUILT_IN_CTANL = int (BUILT_IN_CTANL),
CFN_BUILT_IN_BCMP = int (BUILT_IN_BCMP),
CFN_BUILT_IN_BCOPY = int (BUILT_IN_BCOPY),
CFN_BUILT_IN_BZERO = int (BUILT_IN_BZERO),
CFN_BUILT_IN_INDEX = int (BUILT_IN_INDEX),
CFN_BUILT_IN_MEMCHR = int (BUILT_IN_MEMCHR),
CFN_BUILT_IN_MEMCMP = int (BUILT_IN_MEMCMP),
CFN_BUILT_IN_MEMCPY = int (BUILT_IN_MEMCPY),
CFN_BUILT_IN_MEMMOVE = int (BUILT_IN_MEMMOVE),
CFN_BUILT_IN_MEMPCPY = int (BUILT_IN_MEMPCPY),
CFN_BUILT_IN_MEMSET = int (BUILT_IN_MEMSET),
CFN_BUILT_IN_RINDEX = int (BUILT_IN_RINDEX),
CFN_BUILT_IN_STPCPY = int (BUILT_IN_STPCPY),
CFN_BUILT_IN_STPNCPY = int (BUILT_IN_STPNCPY),
CFN_BUILT_IN_STRCASECMP = int (BUILT_IN_STRCASECMP),
CFN_BUILT_IN_STRCAT = int (BUILT_IN_STRCAT),
CFN_BUILT_IN_STRCHR = int (BUILT_IN_STRCHR),
CFN_BUILT_IN_STRCMP = int (BUILT_IN_STRCMP),
CFN_BUILT_IN_STRCPY = int (BUILT_IN_STRCPY),
CFN_BUILT_IN_STRCSPN = int (BUILT_IN_STRCSPN),
CFN_BUILT_IN_STRDUP = int (BUILT_IN_STRDUP),
CFN_BUILT_IN_STRNDUP = int (BUILT_IN_STRNDUP),
CFN_BUILT_IN_STRLEN = int (BUILT_IN_STRLEN),
CFN_BUILT_IN_STRNCASECMP = int (BUILT_IN_STRNCASECMP),
CFN_BUILT_IN_STRNCAT = int (BUILT_IN_STRNCAT),
CFN_BUILT_IN_STRNCMP = int (BUILT_IN_STRNCMP),
CFN_BUILT_IN_STRNCPY = int (BUILT_IN_STRNCPY),
CFN_BUILT_IN_STRNLEN = int (BUILT_IN_STRNLEN),
CFN_BUILT_IN_STRPBRK = int (BUILT_IN_STRPBRK),
CFN_BUILT_IN_STRRCHR = int (BUILT_IN_STRRCHR),
CFN_BUILT_IN_STRSPN = int (BUILT_IN_STRSPN),
CFN_BUILT_IN_STRSTR = int (BUILT_IN_STRSTR),
CFN_BUILT_IN_FPRINTF = int (BUILT_IN_FPRINTF),
CFN_BUILT_IN_FPRINTF_UNLOCKED = int (BUILT_IN_FPRINTF_UNLOCKED),
CFN_BUILT_IN_PUTC = int (BUILT_IN_PUTC),
CFN_BUILT_IN_PUTC_UNLOCKED = int (BUILT_IN_PUTC_UNLOCKED),
CFN_BUILT_IN_FPUTC = int (BUILT_IN_FPUTC),
CFN_BUILT_IN_FPUTC_UNLOCKED = int (BUILT_IN_FPUTC_UNLOCKED),
CFN_BUILT_IN_FPUTS = int (BUILT_IN_FPUTS),
CFN_BUILT_IN_FPUTS_UNLOCKED = int (BUILT_IN_FPUTS_UNLOCKED),
CFN_BUILT_IN_FSCANF = int (BUILT_IN_FSCANF),
CFN_BUILT_IN_FWRITE = int (BUILT_IN_FWRITE),
CFN_BUILT_IN_FWRITE_UNLOCKED = int (BUILT_IN_FWRITE_UNLOCKED),
CFN_BUILT_IN_PRINTF = int (BUILT_IN_PRINTF),
CFN_BUILT_IN_PRINTF_UNLOCKED = int (BUILT_IN_PRINTF_UNLOCKED),
CFN_BUILT_IN_PUTCHAR = int (BUILT_IN_PUTCHAR),
CFN_BUILT_IN_PUTCHAR_UNLOCKED = int (BUILT_IN_PUTCHAR_UNLOCKED),
CFN_BUILT_IN_PUTS = int (BUILT_IN_PUTS),
CFN_BUILT_IN_PUTS_UNLOCKED = int (BUILT_IN_PUTS_UNLOCKED),
CFN_BUILT_IN_SCANF = int (BUILT_IN_SCANF),
CFN_BUILT_IN_SNPRINTF = int (BUILT_IN_SNPRINTF),
CFN_BUILT_IN_SPRINTF = int (BUILT_IN_SPRINTF),
CFN_BUILT_IN_SSCANF = int (BUILT_IN_SSCANF),
CFN_BUILT_IN_VFPRINTF = int (BUILT_IN_VFPRINTF),
CFN_BUILT_IN_VFSCANF = int (BUILT_IN_VFSCANF),
CFN_BUILT_IN_VPRINTF = int (BUILT_IN_VPRINTF),
CFN_BUILT_IN_VSCANF = int (BUILT_IN_VSCANF),
CFN_BUILT_IN_VSNPRINTF = int (BUILT_IN_VSNPRINTF),
CFN_BUILT_IN_VSPRINTF = int (BUILT_IN_VSPRINTF),
CFN_BUILT_IN_VSSCANF = int (BUILT_IN_VSSCANF),
CFN_BUILT_IN_ISALNUM = int (BUILT_IN_ISALNUM),
CFN_BUILT_IN_ISALPHA = int (BUILT_IN_ISALPHA),
CFN_BUILT_IN_ISASCII = int (BUILT_IN_ISASCII),
CFN_BUILT_IN_ISBLANK = int (BUILT_IN_ISBLANK),
CFN_BUILT_IN_ISCNTRL = int (BUILT_IN_ISCNTRL),
CFN_BUILT_IN_ISDIGIT = int (BUILT_IN_ISDIGIT),
CFN_BUILT_IN_ISGRAPH = int (BUILT_IN_ISGRAPH),
CFN_BUILT_IN_ISLOWER = int (BUILT_IN_ISLOWER),
CFN_BUILT_IN_ISPRINT = int (BUILT_IN_ISPRINT),
CFN_BUILT_IN_ISPUNCT = int (BUILT_IN_ISPUNCT),
CFN_BUILT_IN_ISSPACE = int (BUILT_IN_ISSPACE),
CFN_BUILT_IN_ISUPPER = int (BUILT_IN_ISUPPER),
CFN_BUILT_IN_ISXDIGIT = int (BUILT_IN_ISXDIGIT),
CFN_BUILT_IN_TOASCII = int (BUILT_IN_TOASCII),
CFN_BUILT_IN_TOLOWER = int (BUILT_IN_TOLOWER),
CFN_BUILT_IN_TOUPPER = int (BUILT_IN_TOUPPER),
CFN_BUILT_IN_ISWALNUM = int (BUILT_IN_ISWALNUM),
CFN_BUILT_IN_ISWALPHA = int (BUILT_IN_ISWALPHA),
CFN_BUILT_IN_ISWBLANK = int (BUILT_IN_ISWBLANK),
CFN_BUILT_IN_ISWCNTRL = int (BUILT_IN_ISWCNTRL),
CFN_BUILT_IN_ISWDIGIT = int (BUILT_IN_ISWDIGIT),
CFN_BUILT_IN_ISWGRAPH = int (BUILT_IN_ISWGRAPH),
CFN_BUILT_IN_ISWLOWER = int (BUILT_IN_ISWLOWER),
CFN_BUILT_IN_ISWPRINT = int (BUILT_IN_ISWPRINT),
CFN_BUILT_IN_ISWPUNCT = int (BUILT_IN_ISWPUNCT),
CFN_BUILT_IN_ISWSPACE = int (BUILT_IN_ISWSPACE),
CFN_BUILT_IN_ISWUPPER = int (BUILT_IN_ISWUPPER),
CFN_BUILT_IN_ISWXDIGIT = int (BUILT_IN_ISWXDIGIT),
CFN_BUILT_IN_TOWLOWER = int (BUILT_IN_TOWLOWER),
CFN_BUILT_IN_TOWUPPER = int (BUILT_IN_TOWUPPER),
CFN_BUILT_IN_ADD_OVERFLOW = int (BUILT_IN_ADD_OVERFLOW),
CFN_BUILT_IN_SUB_OVERFLOW = int (BUILT_IN_SUB_OVERFLOW),
CFN_BUILT_IN_MUL_OVERFLOW = int (BUILT_IN_MUL_OVERFLOW),
CFN_BUILT_IN_ADD_OVERFLOW_P = int (BUILT_IN_ADD_OVERFLOW_P),
CFN_BUILT_IN_SUB_OVERFLOW_P = int (BUILT_IN_SUB_OVERFLOW_P),
CFN_BUILT_IN_MUL_OVERFLOW_P = int (BUILT_IN_MUL_OVERFLOW_P),
CFN_BUILT_IN_SADD_OVERFLOW = int (BUILT_IN_SADD_OVERFLOW),
CFN_BUILT_IN_SADDL_OVERFLOW = int (BUILT_IN_SADDL_OVERFLOW),
CFN_BUILT_IN_SADDLL_OVERFLOW = int (BUILT_IN_SADDLL_OVERFLOW),
CFN_BUILT_IN_SSUB_OVERFLOW = int (BUILT_IN_SSUB_OVERFLOW),
CFN_BUILT_IN_SSUBL_OVERFLOW = int (BUILT_IN_SSUBL_OVERFLOW),
CFN_BUILT_IN_SSUBLL_OVERFLOW = int (BUILT_IN_SSUBLL_OVERFLOW),
CFN_BUILT_IN_SMUL_OVERFLOW = int (BUILT_IN_SMUL_OVERFLOW),
CFN_BUILT_IN_SMULL_OVERFLOW = int (BUILT_IN_SMULL_OVERFLOW),
CFN_BUILT_IN_SMULLL_OVERFLOW = int (BUILT_IN_SMULLL_OVERFLOW),
CFN_BUILT_IN_UADD_OVERFLOW = int (BUILT_IN_UADD_OVERFLOW),
CFN_BUILT_IN_UADDL_OVERFLOW = int (BUILT_IN_UADDL_OVERFLOW),
CFN_BUILT_IN_UADDLL_OVERFLOW = int (BUILT_IN_UADDLL_OVERFLOW),
CFN_BUILT_IN_USUB_OVERFLOW = int (BUILT_IN_USUB_OVERFLOW),
CFN_BUILT_IN_USUBL_OVERFLOW = int (BUILT_IN_USUBL_OVERFLOW),
CFN_BUILT_IN_USUBLL_OVERFLOW = int (BUILT_IN_USUBLL_OVERFLOW),
CFN_BUILT_IN_UMUL_OVERFLOW = int (BUILT_IN_UMUL_OVERFLOW),
CFN_BUILT_IN_UMULL_OVERFLOW = int (BUILT_IN_UMULL_OVERFLOW),
CFN_BUILT_IN_UMULLL_OVERFLOW = int (BUILT_IN_UMULLL_OVERFLOW),
CFN_BUILT_IN_ABORT = int (BUILT_IN_ABORT),
CFN_BUILT_IN_ABS = int (BUILT_IN_ABS),
CFN_BUILT_IN_AGGREGATE_INCOMING_ADDRESS = int (BUILT_IN_AGGREGATE_INCOMING_ADDRESS),
CFN_BUILT_IN_ALLOCA = int (BUILT_IN_ALLOCA),
CFN_BUILT_IN_APPLY = int (BUILT_IN_APPLY),
CFN_BUILT_IN_APPLY_ARGS = int (BUILT_IN_APPLY_ARGS),
CFN_BUILT_IN_BSWAP16 = int (BUILT_IN_BSWAP16),
CFN_BUILT_IN_BSWAP32 = int (BUILT_IN_BSWAP32),
CFN_BUILT_IN_BSWAP64 = int (BUILT_IN_BSWAP64),
CFN_BUILT_IN_BSWAP128 = int (BUILT_IN_BSWAP128),
CFN_BUILT_IN_CLEAR_CACHE = int (BUILT_IN_CLEAR_CACHE),
CFN_BUILT_IN_CALLOC = int (BUILT_IN_CALLOC),
CFN_BUILT_IN_CLASSIFY_TYPE = int (BUILT_IN_CLASSIFY_TYPE),
CFN_BUILT_IN_CLZ = int (BUILT_IN_CLZ),
CFN_BUILT_IN_CLZIMAX = int (BUILT_IN_CLZIMAX),
CFN_BUILT_IN_CLZL = int (BUILT_IN_CLZL),
CFN_BUILT_IN_CLZLL = int (BUILT_IN_CLZLL),
CFN_BUILT_IN_CONSTANT_P = int (BUILT_IN_CONSTANT_P),
CFN_BUILT_IN_CTZ = int (BUILT_IN_CTZ),
CFN_BUILT_IN_CTZIMAX = int (BUILT_IN_CTZIMAX),
CFN_BUILT_IN_CTZL = int (BUILT_IN_CTZL),
CFN_BUILT_IN_CTZLL = int (BUILT_IN_CTZLL),
CFN_BUILT_IN_CLRSB = int (BUILT_IN_CLRSB),
CFN_BUILT_IN_CLRSBIMAX = int (BUILT_IN_CLRSBIMAX),
CFN_BUILT_IN_CLRSBL = int (BUILT_IN_CLRSBL),
CFN_BUILT_IN_CLRSBLL = int (BUILT_IN_CLRSBLL),
CFN_BUILT_IN_DCGETTEXT = int (BUILT_IN_DCGETTEXT),
CFN_BUILT_IN_DGETTEXT = int (BUILT_IN_DGETTEXT),
CFN_BUILT_IN_DWARF_CFA = int (BUILT_IN_DWARF_CFA),
CFN_BUILT_IN_DWARF_SP_COLUMN = int (BUILT_IN_DWARF_SP_COLUMN),
CFN_BUILT_IN_EH_RETURN = int (BUILT_IN_EH_RETURN),
CFN_BUILT_IN_EH_RETURN_DATA_REGNO = int (BUILT_IN_EH_RETURN_DATA_REGNO),
CFN_BUILT_IN_EXECL = int (BUILT_IN_EXECL),
CFN_BUILT_IN_EXECLP = int (BUILT_IN_EXECLP),
CFN_BUILT_IN_EXECLE = int (BUILT_IN_EXECLE),
CFN_BUILT_IN_EXECV = int (BUILT_IN_EXECV),
CFN_BUILT_IN_EXECVP = int (BUILT_IN_EXECVP),
CFN_BUILT_IN_EXECVE = int (BUILT_IN_EXECVE),
CFN_BUILT_IN_EXIT = int (BUILT_IN_EXIT),
CFN_BUILT_IN_EXPECT = int (BUILT_IN_EXPECT),
CFN_BUILT_IN_EXPECT_WITH_PROBABILITY = int (BUILT_IN_EXPECT_WITH_PROBABILITY),
CFN_BUILT_IN_ASSUME_ALIGNED = int (BUILT_IN_ASSUME_ALIGNED),
CFN_BUILT_IN_EXTEND_POINTER = int (BUILT_IN_EXTEND_POINTER),
CFN_BUILT_IN_EXTRACT_RETURN_ADDR = int (BUILT_IN_EXTRACT_RETURN_ADDR),
CFN_BUILT_IN_FFS = int (BUILT_IN_FFS),
CFN_BUILT_IN_FFSIMAX = int (BUILT_IN_FFSIMAX),
CFN_BUILT_IN_FFSL = int (BUILT_IN_FFSL),
CFN_BUILT_IN_FFSLL = int (BUILT_IN_FFSLL),
CFN_BUILT_IN_FORK = int (BUILT_IN_FORK),
CFN_BUILT_IN_FRAME_ADDRESS = int (BUILT_IN_FRAME_ADDRESS),
CFN_BUILT_IN_FREE = int (BUILT_IN_FREE),
CFN_BUILT_IN_FROB_RETURN_ADDR = int (BUILT_IN_FROB_RETURN_ADDR),
CFN_BUILT_IN_GETTEXT = int (BUILT_IN_GETTEXT),
CFN_BUILT_IN_IMAXABS = int (BUILT_IN_IMAXABS),
CFN_BUILT_IN_INIT_DWARF_REG_SIZES = int (BUILT_IN_INIT_DWARF_REG_SIZES),
CFN_BUILT_IN_FINITE = int (BUILT_IN_FINITE),
CFN_BUILT_IN_FINITEF = int (BUILT_IN_FINITEF),
CFN_BUILT_IN_FINITEL = int (BUILT_IN_FINITEL),
CFN_BUILT_IN_FINITED32 = int (BUILT_IN_FINITED32),
CFN_BUILT_IN_FINITED64 = int (BUILT_IN_FINITED64),
CFN_BUILT_IN_FINITED128 = int (BUILT_IN_FINITED128),
CFN_BUILT_IN_FPCLASSIFY = int (BUILT_IN_FPCLASSIFY),
CFN_BUILT_IN_ISFINITE = int (BUILT_IN_ISFINITE),
CFN_BUILT_IN_ISINF_SIGN = int (BUILT_IN_ISINF_SIGN),
CFN_BUILT_IN_ISINF = int (BUILT_IN_ISINF),
CFN_BUILT_IN_ISINFF = int (BUILT_IN_ISINFF),
CFN_BUILT_IN_ISINFL = int (BUILT_IN_ISINFL),
CFN_BUILT_IN_ISINFD32 = int (BUILT_IN_ISINFD32),
CFN_BUILT_IN_ISINFD64 = int (BUILT_IN_ISINFD64),
CFN_BUILT_IN_ISINFD128 = int (BUILT_IN_ISINFD128),
CFN_BUILT_IN_ISNAN = int (BUILT_IN_ISNAN),
CFN_BUILT_IN_ISNANF = int (BUILT_IN_ISNANF),
CFN_BUILT_IN_ISNANL = int (BUILT_IN_ISNANL),
CFN_BUILT_IN_ISNAND32 = int (BUILT_IN_ISNAND32),
CFN_BUILT_IN_ISNAND64 = int (BUILT_IN_ISNAND64),
CFN_BUILT_IN_ISNAND128 = int (BUILT_IN_ISNAND128),
CFN_BUILT_IN_ISNORMAL = int (BUILT_IN_ISNORMAL),
CFN_BUILT_IN_ISGREATER = int (BUILT_IN_ISGREATER),
CFN_BUILT_IN_ISGREATEREQUAL = int (BUILT_IN_ISGREATEREQUAL),
CFN_BUILT_IN_ISLESS = int (BUILT_IN_ISLESS),
CFN_BUILT_IN_ISLESSEQUAL = int (BUILT_IN_ISLESSEQUAL),
CFN_BUILT_IN_ISLESSGREATER = int (BUILT_IN_ISLESSGREATER),
CFN_BUILT_IN_ISUNORDERED = int (BUILT_IN_ISUNORDERED),
CFN_BUILT_IN_LABS = int (BUILT_IN_LABS),
CFN_BUILT_IN_LLABS = int (BUILT_IN_LLABS),
CFN_BUILT_IN_LONGJMP = int (BUILT_IN_LONGJMP),
CFN_BUILT_IN_MALLOC = int (BUILT_IN_MALLOC),
CFN_BUILT_IN_NEXT_ARG = int (BUILT_IN_NEXT_ARG),
CFN_BUILT_IN_PARITY = int (BUILT_IN_PARITY),
CFN_BUILT_IN_PARITYIMAX = int (BUILT_IN_PARITYIMAX),
CFN_BUILT_IN_PARITYL = int (BUILT_IN_PARITYL),
CFN_BUILT_IN_PARITYLL = int (BUILT_IN_PARITYLL),
CFN_BUILT_IN_POPCOUNT = int (BUILT_IN_POPCOUNT),
CFN_BUILT_IN_POPCOUNTIMAX = int (BUILT_IN_POPCOUNTIMAX),
CFN_BUILT_IN_POPCOUNTL = int (BUILT_IN_POPCOUNTL),
CFN_BUILT_IN_POPCOUNTLL = int (BUILT_IN_POPCOUNTLL),
CFN_BUILT_IN_POSIX_MEMALIGN = int (BUILT_IN_POSIX_MEMALIGN),
CFN_BUILT_IN_PREFETCH = int (BUILT_IN_PREFETCH),
CFN_BUILT_IN_REALLOC = int (BUILT_IN_REALLOC),
CFN_BUILT_IN_RETURN = int (BUILT_IN_RETURN),
CFN_BUILT_IN_RETURN_ADDRESS = int (BUILT_IN_RETURN_ADDRESS),
CFN_BUILT_IN_SAVEREGS = int (BUILT_IN_SAVEREGS),
CFN_BUILT_IN_SETJMP = int (BUILT_IN_SETJMP),
CFN_BUILT_IN_STRFMON = int (BUILT_IN_STRFMON),
CFN_BUILT_IN_STRFTIME = int (BUILT_IN_STRFTIME),
CFN_BUILT_IN_TRAP = int (BUILT_IN_TRAP),
CFN_BUILT_IN_UNREACHABLE = int (BUILT_IN_UNREACHABLE),
CFN_BUILT_IN_UNWIND_INIT = int (BUILT_IN_UNWIND_INIT),
CFN_BUILT_IN_UPDATE_SETJMP_BUF = int (BUILT_IN_UPDATE_SETJMP_BUF),
CFN_BUILT_IN_VA_COPY = int (BUILT_IN_VA_COPY),
CFN_BUILT_IN_VA_END = int (BUILT_IN_VA_END),
CFN_BUILT_IN_VA_START = int (BUILT_IN_VA_START),
CFN_BUILT_IN_VA_ARG_PACK = int (BUILT_IN_VA_ARG_PACK),
CFN_BUILT_IN_VA_ARG_PACK_LEN = int (BUILT_IN_VA_ARG_PACK_LEN),
CFN_BUILT_IN__EXIT = int (BUILT_IN__EXIT),
CFN_BUILT_IN__EXIT2 = int (BUILT_IN__EXIT2),
CFN_BUILT_IN_INIT_TRAMPOLINE = int (BUILT_IN_INIT_TRAMPOLINE),
CFN_BUILT_IN_INIT_HEAP_TRAMPOLINE = int (BUILT_IN_INIT_HEAP_TRAMPOLINE),
CFN_BUILT_IN_ADJUST_TRAMPOLINE = int (BUILT_IN_ADJUST_TRAMPOLINE),
CFN_BUILT_IN_INIT_DESCRIPTOR = int (BUILT_IN_INIT_DESCRIPTOR),
CFN_BUILT_IN_ADJUST_DESCRIPTOR = int (BUILT_IN_ADJUST_DESCRIPTOR),
CFN_BUILT_IN_NONLOCAL_GOTO = int (BUILT_IN_NONLOCAL_GOTO),
CFN_BUILT_IN_SETJMP_SETUP = int (BUILT_IN_SETJMP_SETUP),
CFN_BUILT_IN_SETJMP_RECEIVER = int (BUILT_IN_SETJMP_RECEIVER),
CFN_BUILT_IN_STACK_SAVE = int (BUILT_IN_STACK_SAVE),
CFN_BUILT_IN_STACK_RESTORE = int (BUILT_IN_STACK_RESTORE),
CFN_BUILT_IN_ALLOCA_WITH_ALIGN = int (BUILT_IN_ALLOCA_WITH_ALIGN),
CFN_BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX = int (BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX),
CFN_BUILT_IN_MEMCMP_EQ = int (BUILT_IN_MEMCMP_EQ),
CFN_BUILT_IN_STRCMP_EQ = int (BUILT_IN_STRCMP_EQ),
CFN_BUILT_IN_STRNCMP_EQ = int (BUILT_IN_STRNCMP_EQ),
CFN_BUILT_IN_OBJECT_SIZE = int (BUILT_IN_OBJECT_SIZE),
CFN_BUILT_IN_MEMCPY_CHK = int (BUILT_IN_MEMCPY_CHK),
CFN_BUILT_IN_MEMMOVE_CHK = int (BUILT_IN_MEMMOVE_CHK),
CFN_BUILT_IN_MEMPCPY_CHK = int (BUILT_IN_MEMPCPY_CHK),
CFN_BUILT_IN_MEMSET_CHK = int (BUILT_IN_MEMSET_CHK),
CFN_BUILT_IN_STPCPY_CHK = int (BUILT_IN_STPCPY_CHK),
CFN_BUILT_IN_STPNCPY_CHK = int (BUILT_IN_STPNCPY_CHK),
CFN_BUILT_IN_STRCAT_CHK = int (BUILT_IN_STRCAT_CHK),
CFN_BUILT_IN_STRCPY_CHK = int (BUILT_IN_STRCPY_CHK),
CFN_BUILT_IN_STRNCAT_CHK = int (BUILT_IN_STRNCAT_CHK),
CFN_BUILT_IN_STRNCPY_CHK = int (BUILT_IN_STRNCPY_CHK),
CFN_BUILT_IN_SNPRINTF_CHK = int (BUILT_IN_SNPRINTF_CHK),
CFN_BUILT_IN_SPRINTF_CHK = int (BUILT_IN_SPRINTF_CHK),
CFN_BUILT_IN_VSNPRINTF_CHK = int (BUILT_IN_VSNPRINTF_CHK),
CFN_BUILT_IN_VSPRINTF_CHK = int (BUILT_IN_VSPRINTF_CHK),
CFN_BUILT_IN_FPRINTF_CHK = int (BUILT_IN_FPRINTF_CHK),
CFN_BUILT_IN_PRINTF_CHK = int (BUILT_IN_PRINTF_CHK),
CFN_BUILT_IN_VFPRINTF_CHK = int (BUILT_IN_VFPRINTF_CHK),
CFN_BUILT_IN_VPRINTF_CHK = int (BUILT_IN_VPRINTF_CHK),
CFN_BUILT_IN_PROFILE_FUNC_ENTER = int (BUILT_IN_PROFILE_FUNC_ENTER),
CFN_BUILT_IN_PROFILE_FUNC_EXIT = int (BUILT_IN_PROFILE_FUNC_EXIT),
CFN_BUILT_IN_THREAD_POINTER = int (BUILT_IN_THREAD_POINTER),
CFN_BUILT_IN_SET_THREAD_POINTER = int (BUILT_IN_SET_THREAD_POINTER),
CFN_BUILT_IN_EMUTLS_GET_ADDRESS = int (BUILT_IN_EMUTLS_GET_ADDRESS),
CFN_BUILT_IN_EMUTLS_REGISTER_COMMON = int (BUILT_IN_EMUTLS_REGISTER_COMMON),
# 1017 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def"
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_N = int (BUILT_IN_SPECULATION_SAFE_VALUE_N),
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_PTR = int (BUILT_IN_SPECULATION_SAFE_VALUE_PTR),
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_1 = int (BUILT_IN_SPECULATION_SAFE_VALUE_1),
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_2 = int (BUILT_IN_SPECULATION_SAFE_VALUE_2),
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_4 = int (BUILT_IN_SPECULATION_SAFE_VALUE_4),
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_8 = int (BUILT_IN_SPECULATION_SAFE_VALUE_8),
CFN_BUILT_IN_SPECULATION_SAFE_VALUE_16 = int (BUILT_IN_SPECULATION_SAFE_VALUE_16),
CFN_BUILT_IN_UNWIND_RESUME = int (BUILT_IN_UNWIND_RESUME),
CFN_BUILT_IN_CXA_END_CLEANUP = int (BUILT_IN_CXA_END_CLEANUP),
CFN_BUILT_IN_EH_POINTER = int (BUILT_IN_EH_POINTER),
CFN_BUILT_IN_EH_FILTER = int (BUILT_IN_EH_FILTER),
CFN_BUILT_IN_EH_COPY_VALUES = int (BUILT_IN_EH_COPY_VALUES),
CFN_BUILT_IN_FILE = int (BUILT_IN_FILE),
CFN_BUILT_IN_FUNCTION = int (BUILT_IN_FUNCTION),
CFN_BUILT_IN_LINE = int (BUILT_IN_LINE),
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/sync-builtins.def" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/sync-builtins.def"
CFN_BUILT_IN_SYNC_FETCH_AND_ADD_N = int (BUILT_IN_SYNC_FETCH_AND_ADD_N),
CFN_BUILT_IN_SYNC_FETCH_AND_ADD_1 = int (BUILT_IN_SYNC_FETCH_AND_ADD_1),
CFN_BUILT_IN_SYNC_FETCH_AND_ADD_2 = int (BUILT_IN_SYNC_FETCH_AND_ADD_2),
CFN_BUILT_IN_SYNC_FETCH_AND_ADD_4 = int (BUILT_IN_SYNC_FETCH_AND_ADD_4),
CFN_BUILT_IN_SYNC_FETCH_AND_ADD_8 = int (BUILT_IN_SYNC_FETCH_AND_ADD_8),
CFN_BUILT_IN_SYNC_FETCH_AND_ADD_16 = int (BUILT_IN_SYNC_FETCH_AND_ADD_16),
CFN_BUILT_IN_SYNC_FETCH_AND_SUB_N = int (BUILT_IN_SYNC_FETCH_AND_SUB_N),
CFN_BUILT_IN_SYNC_FETCH_AND_SUB_1 = int (BUILT_IN_SYNC_FETCH_AND_SUB_1),
CFN_BUILT_IN_SYNC_FETCH_AND_SUB_2 = int (BUILT_IN_SYNC_FETCH_AND_SUB_2),
CFN_BUILT_IN_SYNC_FETCH_AND_SUB_4 = int (BUILT_IN_SYNC_FETCH_AND_SUB_4),
CFN_BUILT_IN_SYNC_FETCH_AND_SUB_8 = int (BUILT_IN_SYNC_FETCH_AND_SUB_8),
CFN_BUILT_IN_SYNC_FETCH_AND_SUB_16 = int (BUILT_IN_SYNC_FETCH_AND_SUB_16),
CFN_BUILT_IN_SYNC_FETCH_AND_OR_N = int (BUILT_IN_SYNC_FETCH_AND_OR_N),
CFN_BUILT_IN_SYNC_FETCH_AND_OR_1 = int (BUILT_IN_SYNC_FETCH_AND_OR_1),
CFN_BUILT_IN_SYNC_FETCH_AND_OR_2 = int (BUILT_IN_SYNC_FETCH_AND_OR_2),
CFN_BUILT_IN_SYNC_FETCH_AND_OR_4 = int (BUILT_IN_SYNC_FETCH_AND_OR_4),
CFN_BUILT_IN_SYNC_FETCH_AND_OR_8 = int (BUILT_IN_SYNC_FETCH_AND_OR_8),
CFN_BUILT_IN_SYNC_FETCH_AND_OR_16 = int (BUILT_IN_SYNC_FETCH_AND_OR_16),
CFN_BUILT_IN_SYNC_FETCH_AND_AND_N = int (BUILT_IN_SYNC_FETCH_AND_AND_N),
CFN_BUILT_IN_SYNC_FETCH_AND_AND_1 = int (BUILT_IN_SYNC_FETCH_AND_AND_1),
CFN_BUILT_IN_SYNC_FETCH_AND_AND_2 = int (BUILT_IN_SYNC_FETCH_AND_AND_2),
CFN_BUILT_IN_SYNC_FETCH_AND_AND_4 = int (BUILT_IN_SYNC_FETCH_AND_AND_4),
CFN_BUILT_IN_SYNC_FETCH_AND_AND_8 = int (BUILT_IN_SYNC_FETCH_AND_AND_8),
CFN_BUILT_IN_SYNC_FETCH_AND_AND_16 = int (BUILT_IN_SYNC_FETCH_AND_AND_16),
CFN_BUILT_IN_SYNC_FETCH_AND_XOR_N = int (BUILT_IN_SYNC_FETCH_AND_XOR_N),
CFN_BUILT_IN_SYNC_FETCH_AND_XOR_1 = int (BUILT_IN_SYNC_FETCH_AND_XOR_1),
CFN_BUILT_IN_SYNC_FETCH_AND_XOR_2 = int (BUILT_IN_SYNC_FETCH_AND_XOR_2),
CFN_BUILT_IN_SYNC_FETCH_AND_XOR_4 = int (BUILT_IN_SYNC_FETCH_AND_XOR_4),
CFN_BUILT_IN_SYNC_FETCH_AND_XOR_8 = int (BUILT_IN_SYNC_FETCH_AND_XOR_8),
CFN_BUILT_IN_SYNC_FETCH_AND_XOR_16 = int (BUILT_IN_SYNC_FETCH_AND_XOR_16),
CFN_BUILT_IN_SYNC_FETCH_AND_NAND_N = int (BUILT_IN_SYNC_FETCH_AND_NAND_N),
CFN_BUILT_IN_SYNC_FETCH_AND_NAND_1 = int (BUILT_IN_SYNC_FETCH_AND_NAND_1),
CFN_BUILT_IN_SYNC_FETCH_AND_NAND_2 = int (BUILT_IN_SYNC_FETCH_AND_NAND_2),
CFN_BUILT_IN_SYNC_FETCH_AND_NAND_4 = int (BUILT_IN_SYNC_FETCH_AND_NAND_4),
CFN_BUILT_IN_SYNC_FETCH_AND_NAND_8 = int (BUILT_IN_SYNC_FETCH_AND_NAND_8),
CFN_BUILT_IN_SYNC_FETCH_AND_NAND_16 = int (BUILT_IN_SYNC_FETCH_AND_NAND_16),
CFN_BUILT_IN_SYNC_ADD_AND_FETCH_N = int (BUILT_IN_SYNC_ADD_AND_FETCH_N),
CFN_BUILT_IN_SYNC_ADD_AND_FETCH_1 = int (BUILT_IN_SYNC_ADD_AND_FETCH_1),
CFN_BUILT_IN_SYNC_ADD_AND_FETCH_2 = int (BUILT_IN_SYNC_ADD_AND_FETCH_2),
CFN_BUILT_IN_SYNC_ADD_AND_FETCH_4 = int (BUILT_IN_SYNC_ADD_AND_FETCH_4),
CFN_BUILT_IN_SYNC_ADD_AND_FETCH_8 = int (BUILT_IN_SYNC_ADD_AND_FETCH_8),
CFN_BUILT_IN_SYNC_ADD_AND_FETCH_16 = int (BUILT_IN_SYNC_ADD_AND_FETCH_16),
CFN_BUILT_IN_SYNC_SUB_AND_FETCH_N = int (BUILT_IN_SYNC_SUB_AND_FETCH_N),
CFN_BUILT_IN_SYNC_SUB_AND_FETCH_1 = int (BUILT_IN_SYNC_SUB_AND_FETCH_1),
CFN_BUILT_IN_SYNC_SUB_AND_FETCH_2 = int (BUILT_IN_SYNC_SUB_AND_FETCH_2),
CFN_BUILT_IN_SYNC_SUB_AND_FETCH_4 = int (BUILT_IN_SYNC_SUB_AND_FETCH_4),
CFN_BUILT_IN_SYNC_SUB_AND_FETCH_8 = int (BUILT_IN_SYNC_SUB_AND_FETCH_8),
CFN_BUILT_IN_SYNC_SUB_AND_FETCH_16 = int (BUILT_IN_SYNC_SUB_AND_FETCH_16),
CFN_BUILT_IN_SYNC_OR_AND_FETCH_N = int (BUILT_IN_SYNC_OR_AND_FETCH_N),
CFN_BUILT_IN_SYNC_OR_AND_FETCH_1 = int (BUILT_IN_SYNC_OR_AND_FETCH_1),
CFN_BUILT_IN_SYNC_OR_AND_FETCH_2 = int (BUILT_IN_SYNC_OR_AND_FETCH_2),
CFN_BUILT_IN_SYNC_OR_AND_FETCH_4 = int (BUILT_IN_SYNC_OR_AND_FETCH_4),
CFN_BUILT_IN_SYNC_OR_AND_FETCH_8 = int (BUILT_IN_SYNC_OR_AND_FETCH_8),
CFN_BUILT_IN_SYNC_OR_AND_FETCH_16 = int (BUILT_IN_SYNC_OR_AND_FETCH_16),
CFN_BUILT_IN_SYNC_AND_AND_FETCH_N = int (BUILT_IN_SYNC_AND_AND_FETCH_N),
CFN_BUILT_IN_SYNC_AND_AND_FETCH_1 = int (BUILT_IN_SYNC_AND_AND_FETCH_1),
CFN_BUILT_IN_SYNC_AND_AND_FETCH_2 = int (BUILT_IN_SYNC_AND_AND_FETCH_2),
CFN_BUILT_IN_SYNC_AND_AND_FETCH_4 = int (BUILT_IN_SYNC_AND_AND_FETCH_4),
CFN_BUILT_IN_SYNC_AND_AND_FETCH_8 = int (BUILT_IN_SYNC_AND_AND_FETCH_8),
CFN_BUILT_IN_SYNC_AND_AND_FETCH_16 = int (BUILT_IN_SYNC_AND_AND_FETCH_16),
CFN_BUILT_IN_SYNC_XOR_AND_FETCH_N = int (BUILT_IN_SYNC_XOR_AND_FETCH_N),
CFN_BUILT_IN_SYNC_XOR_AND_FETCH_1 = int (BUILT_IN_SYNC_XOR_AND_FETCH_1),
CFN_BUILT_IN_SYNC_XOR_AND_FETCH_2 = int (BUILT_IN_SYNC_XOR_AND_FETCH_2),
CFN_BUILT_IN_SYNC_XOR_AND_FETCH_4 = int (BUILT_IN_SYNC_XOR_AND_FETCH_4),
CFN_BUILT_IN_SYNC_XOR_AND_FETCH_8 = int (BUILT_IN_SYNC_XOR_AND_FETCH_8),
CFN_BUILT_IN_SYNC_XOR_AND_FETCH_16 = int (BUILT_IN_SYNC_XOR_AND_FETCH_16),
CFN_BUILT_IN_SYNC_NAND_AND_FETCH_N = int (BUILT_IN_SYNC_NAND_AND_FETCH_N),
CFN_BUILT_IN_SYNC_NAND_AND_FETCH_1 = int (BUILT_IN_SYNC_NAND_AND_FETCH_1),
CFN_BUILT_IN_SYNC_NAND_AND_FETCH_2 = int (BUILT_IN_SYNC_NAND_AND_FETCH_2),
CFN_BUILT_IN_SYNC_NAND_AND_FETCH_4 = int (BUILT_IN_SYNC_NAND_AND_FETCH_4),
CFN_BUILT_IN_SYNC_NAND_AND_FETCH_8 = int (BUILT_IN_SYNC_NAND_AND_FETCH_8),
CFN_BUILT_IN_SYNC_NAND_AND_FETCH_16 = int (BUILT_IN_SYNC_NAND_AND_FETCH_16),
CFN_BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N = int (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N),
CFN_BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1 = int (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1),
CFN_BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2 = int (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2),
CFN_BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4 = int (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4),
CFN_BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8 = int (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8),
CFN_BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16 = int (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16),
CFN_BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N = int (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N),
CFN_BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1 = int (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1),
CFN_BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2 = int (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2),
CFN_BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4 = int (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4),
CFN_BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8 = int (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8),
CFN_BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16 = int (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16),
CFN_BUILT_IN_SYNC_LOCK_TEST_AND_SET_N = int (BUILT_IN_SYNC_LOCK_TEST_AND_SET_N),
CFN_BUILT_IN_SYNC_LOCK_TEST_AND_SET_1 = int (BUILT_IN_SYNC_LOCK_TEST_AND_SET_1),
CFN_BUILT_IN_SYNC_LOCK_TEST_AND_SET_2 = int (BUILT_IN_SYNC_LOCK_TEST_AND_SET_2),
CFN_BUILT_IN_SYNC_LOCK_TEST_AND_SET_4 = int (BUILT_IN_SYNC_LOCK_TEST_AND_SET_4),
CFN_BUILT_IN_SYNC_LOCK_TEST_AND_SET_8 = int (BUILT_IN_SYNC_LOCK_TEST_AND_SET_8),
CFN_BUILT_IN_SYNC_LOCK_TEST_AND_SET_16 = int (BUILT_IN_SYNC_LOCK_TEST_AND_SET_16),
CFN_BUILT_IN_SYNC_LOCK_RELEASE_N = int (BUILT_IN_SYNC_LOCK_RELEASE_N),
CFN_BUILT_IN_SYNC_LOCK_RELEASE_1 = int (BUILT_IN_SYNC_LOCK_RELEASE_1),
CFN_BUILT_IN_SYNC_LOCK_RELEASE_2 = int (BUILT_IN_SYNC_LOCK_RELEASE_2),
CFN_BUILT_IN_SYNC_LOCK_RELEASE_4 = int (BUILT_IN_SYNC_LOCK_RELEASE_4),
CFN_BUILT_IN_SYNC_LOCK_RELEASE_8 = int (BUILT_IN_SYNC_LOCK_RELEASE_8),
CFN_BUILT_IN_SYNC_LOCK_RELEASE_16 = int (BUILT_IN_SYNC_LOCK_RELEASE_16),
CFN_BUILT_IN_SYNC_SYNCHRONIZE = int (BUILT_IN_SYNC_SYNCHRONIZE),
CFN_BUILT_IN_ATOMIC_TEST_AND_SET = int (BUILT_IN_ATOMIC_TEST_AND_SET),
CFN_BUILT_IN_ATOMIC_CLEAR = int (BUILT_IN_ATOMIC_CLEAR),
CFN_BUILT_IN_ATOMIC_EXCHANGE = int (BUILT_IN_ATOMIC_EXCHANGE),
CFN_BUILT_IN_ATOMIC_EXCHANGE_N = int (BUILT_IN_ATOMIC_EXCHANGE_N),
CFN_BUILT_IN_ATOMIC_EXCHANGE_1 = int (BUILT_IN_ATOMIC_EXCHANGE_1),
CFN_BUILT_IN_ATOMIC_EXCHANGE_2 = int (BUILT_IN_ATOMIC_EXCHANGE_2),
CFN_BUILT_IN_ATOMIC_EXCHANGE_4 = int (BUILT_IN_ATOMIC_EXCHANGE_4),
CFN_BUILT_IN_ATOMIC_EXCHANGE_8 = int (BUILT_IN_ATOMIC_EXCHANGE_8),
CFN_BUILT_IN_ATOMIC_EXCHANGE_16 = int (BUILT_IN_ATOMIC_EXCHANGE_16),
CFN_BUILT_IN_ATOMIC_LOAD = int (BUILT_IN_ATOMIC_LOAD),
CFN_BUILT_IN_ATOMIC_LOAD_N = int (BUILT_IN_ATOMIC_LOAD_N),
CFN_BUILT_IN_ATOMIC_LOAD_1 = int (BUILT_IN_ATOMIC_LOAD_1),
CFN_BUILT_IN_ATOMIC_LOAD_2 = int (BUILT_IN_ATOMIC_LOAD_2),
CFN_BUILT_IN_ATOMIC_LOAD_4 = int (BUILT_IN_ATOMIC_LOAD_4),
CFN_BUILT_IN_ATOMIC_LOAD_8 = int (BUILT_IN_ATOMIC_LOAD_8),
CFN_BUILT_IN_ATOMIC_LOAD_16 = int (BUILT_IN_ATOMIC_LOAD_16),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1 = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2 = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4 = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8 = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8),
CFN_BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16 = int (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16),
CFN_BUILT_IN_ATOMIC_STORE = int (BUILT_IN_ATOMIC_STORE),
CFN_BUILT_IN_ATOMIC_STORE_N = int (BUILT_IN_ATOMIC_STORE_N),
CFN_BUILT_IN_ATOMIC_STORE_1 = int (BUILT_IN_ATOMIC_STORE_1),
CFN_BUILT_IN_ATOMIC_STORE_2 = int (BUILT_IN_ATOMIC_STORE_2),
CFN_BUILT_IN_ATOMIC_STORE_4 = int (BUILT_IN_ATOMIC_STORE_4),
CFN_BUILT_IN_ATOMIC_STORE_8 = int (BUILT_IN_ATOMIC_STORE_8),
CFN_BUILT_IN_ATOMIC_STORE_16 = int (BUILT_IN_ATOMIC_STORE_16),
CFN_BUILT_IN_ATOMIC_ADD_FETCH_N = int (BUILT_IN_ATOMIC_ADD_FETCH_N),
CFN_BUILT_IN_ATOMIC_ADD_FETCH_1 = int (BUILT_IN_ATOMIC_ADD_FETCH_1),
CFN_BUILT_IN_ATOMIC_ADD_FETCH_2 = int (BUILT_IN_ATOMIC_ADD_FETCH_2),
CFN_BUILT_IN_ATOMIC_ADD_FETCH_4 = int (BUILT_IN_ATOMIC_ADD_FETCH_4),
CFN_BUILT_IN_ATOMIC_ADD_FETCH_8 = int (BUILT_IN_ATOMIC_ADD_FETCH_8),
CFN_BUILT_IN_ATOMIC_ADD_FETCH_16 = int (BUILT_IN_ATOMIC_ADD_FETCH_16),
CFN_BUILT_IN_ATOMIC_SUB_FETCH_N = int (BUILT_IN_ATOMIC_SUB_FETCH_N),
CFN_BUILT_IN_ATOMIC_SUB_FETCH_1 = int (BUILT_IN_ATOMIC_SUB_FETCH_1),
CFN_BUILT_IN_ATOMIC_SUB_FETCH_2 = int (BUILT_IN_ATOMIC_SUB_FETCH_2),
CFN_BUILT_IN_ATOMIC_SUB_FETCH_4 = int (BUILT_IN_ATOMIC_SUB_FETCH_4),
CFN_BUILT_IN_ATOMIC_SUB_FETCH_8 = int (BUILT_IN_ATOMIC_SUB_FETCH_8),
CFN_BUILT_IN_ATOMIC_SUB_FETCH_16 = int (BUILT_IN_ATOMIC_SUB_FETCH_16),
CFN_BUILT_IN_ATOMIC_AND_FETCH_N = int (BUILT_IN_ATOMIC_AND_FETCH_N),
CFN_BUILT_IN_ATOMIC_AND_FETCH_1 = int (BUILT_IN_ATOMIC_AND_FETCH_1),
CFN_BUILT_IN_ATOMIC_AND_FETCH_2 = int (BUILT_IN_ATOMIC_AND_FETCH_2),
CFN_BUILT_IN_ATOMIC_AND_FETCH_4 = int (BUILT_IN_ATOMIC_AND_FETCH_4),
CFN_BUILT_IN_ATOMIC_AND_FETCH_8 = int (BUILT_IN_ATOMIC_AND_FETCH_8),
CFN_BUILT_IN_ATOMIC_AND_FETCH_16 = int (BUILT_IN_ATOMIC_AND_FETCH_16),
CFN_BUILT_IN_ATOMIC_NAND_FETCH_N = int (BUILT_IN_ATOMIC_NAND_FETCH_N),
CFN_BUILT_IN_ATOMIC_NAND_FETCH_1 = int (BUILT_IN_ATOMIC_NAND_FETCH_1),
CFN_BUILT_IN_ATOMIC_NAND_FETCH_2 = int (BUILT_IN_ATOMIC_NAND_FETCH_2),
CFN_BUILT_IN_ATOMIC_NAND_FETCH_4 = int (BUILT_IN_ATOMIC_NAND_FETCH_4),
CFN_BUILT_IN_ATOMIC_NAND_FETCH_8 = int (BUILT_IN_ATOMIC_NAND_FETCH_8),
CFN_BUILT_IN_ATOMIC_NAND_FETCH_16 = int (BUILT_IN_ATOMIC_NAND_FETCH_16),
CFN_BUILT_IN_ATOMIC_XOR_FETCH_N = int (BUILT_IN_ATOMIC_XOR_FETCH_N),
CFN_BUILT_IN_ATOMIC_XOR_FETCH_1 = int (BUILT_IN_ATOMIC_XOR_FETCH_1),
CFN_BUILT_IN_ATOMIC_XOR_FETCH_2 = int (BUILT_IN_ATOMIC_XOR_FETCH_2),
CFN_BUILT_IN_ATOMIC_XOR_FETCH_4 = int (BUILT_IN_ATOMIC_XOR_FETCH_4),
CFN_BUILT_IN_ATOMIC_XOR_FETCH_8 = int (BUILT_IN_ATOMIC_XOR_FETCH_8),
CFN_BUILT_IN_ATOMIC_XOR_FETCH_16 = int (BUILT_IN_ATOMIC_XOR_FETCH_16),
CFN_BUILT_IN_ATOMIC_OR_FETCH_N = int (BUILT_IN_ATOMIC_OR_FETCH_N),
CFN_BUILT_IN_ATOMIC_OR_FETCH_1 = int (BUILT_IN_ATOMIC_OR_FETCH_1),
CFN_BUILT_IN_ATOMIC_OR_FETCH_2 = int (BUILT_IN_ATOMIC_OR_FETCH_2),
CFN_BUILT_IN_ATOMIC_OR_FETCH_4 = int (BUILT_IN_ATOMIC_OR_FETCH_4),
CFN_BUILT_IN_ATOMIC_OR_FETCH_8 = int (BUILT_IN_ATOMIC_OR_FETCH_8),
CFN_BUILT_IN_ATOMIC_OR_FETCH_16 = int (BUILT_IN_ATOMIC_OR_FETCH_16),
CFN_BUILT_IN_ATOMIC_FETCH_ADD_N = int (BUILT_IN_ATOMIC_FETCH_ADD_N),
CFN_BUILT_IN_ATOMIC_FETCH_ADD_1 = int (BUILT_IN_ATOMIC_FETCH_ADD_1),
CFN_BUILT_IN_ATOMIC_FETCH_ADD_2 = int (BUILT_IN_ATOMIC_FETCH_ADD_2),
CFN_BUILT_IN_ATOMIC_FETCH_ADD_4 = int (BUILT_IN_ATOMIC_FETCH_ADD_4),
CFN_BUILT_IN_ATOMIC_FETCH_ADD_8 = int (BUILT_IN_ATOMIC_FETCH_ADD_8),
CFN_BUILT_IN_ATOMIC_FETCH_ADD_16 = int (BUILT_IN_ATOMIC_FETCH_ADD_16),
CFN_BUILT_IN_ATOMIC_FETCH_SUB_N = int (BUILT_IN_ATOMIC_FETCH_SUB_N),
CFN_BUILT_IN_ATOMIC_FETCH_SUB_1 = int (BUILT_IN_ATOMIC_FETCH_SUB_1),
CFN_BUILT_IN_ATOMIC_FETCH_SUB_2 = int (BUILT_IN_ATOMIC_FETCH_SUB_2),
CFN_BUILT_IN_ATOMIC_FETCH_SUB_4 = int (BUILT_IN_ATOMIC_FETCH_SUB_4),
CFN_BUILT_IN_ATOMIC_FETCH_SUB_8 = int (BUILT_IN_ATOMIC_FETCH_SUB_8),
CFN_BUILT_IN_ATOMIC_FETCH_SUB_16 = int (BUILT_IN_ATOMIC_FETCH_SUB_16),
CFN_BUILT_IN_ATOMIC_FETCH_AND_N = int (BUILT_IN_ATOMIC_FETCH_AND_N),
CFN_BUILT_IN_ATOMIC_FETCH_AND_1 = int (BUILT_IN_ATOMIC_FETCH_AND_1),
CFN_BUILT_IN_ATOMIC_FETCH_AND_2 = int (BUILT_IN_ATOMIC_FETCH_AND_2),
CFN_BUILT_IN_ATOMIC_FETCH_AND_4 = int (BUILT_IN_ATOMIC_FETCH_AND_4),
CFN_BUILT_IN_ATOMIC_FETCH_AND_8 = int (BUILT_IN_ATOMIC_FETCH_AND_8),
CFN_BUILT_IN_ATOMIC_FETCH_AND_16 = int (BUILT_IN_ATOMIC_FETCH_AND_16),
CFN_BUILT_IN_ATOMIC_FETCH_NAND_N = int (BUILT_IN_ATOMIC_FETCH_NAND_N),
CFN_BUILT_IN_ATOMIC_FETCH_NAND_1 = int (BUILT_IN_ATOMIC_FETCH_NAND_1),
CFN_BUILT_IN_ATOMIC_FETCH_NAND_2 = int (BUILT_IN_ATOMIC_FETCH_NAND_2),
CFN_BUILT_IN_ATOMIC_FETCH_NAND_4 = int (BUILT_IN_ATOMIC_FETCH_NAND_4),
CFN_BUILT_IN_ATOMIC_FETCH_NAND_8 = int (BUILT_IN_ATOMIC_FETCH_NAND_8),
CFN_BUILT_IN_ATOMIC_FETCH_NAND_16 = int (BUILT_IN_ATOMIC_FETCH_NAND_16),
CFN_BUILT_IN_ATOMIC_FETCH_XOR_N = int (BUILT_IN_ATOMIC_FETCH_XOR_N),
CFN_BUILT_IN_ATOMIC_FETCH_XOR_1 = int (BUILT_IN_ATOMIC_FETCH_XOR_1),
CFN_BUILT_IN_ATOMIC_FETCH_XOR_2 = int (BUILT_IN_ATOMIC_FETCH_XOR_2),
CFN_BUILT_IN_ATOMIC_FETCH_XOR_4 = int (BUILT_IN_ATOMIC_FETCH_XOR_4),
CFN_BUILT_IN_ATOMIC_FETCH_XOR_8 = int (BUILT_IN_ATOMIC_FETCH_XOR_8),
CFN_BUILT_IN_ATOMIC_FETCH_XOR_16 = int (BUILT_IN_ATOMIC_FETCH_XOR_16),
CFN_BUILT_IN_ATOMIC_FETCH_OR_N = int (BUILT_IN_ATOMIC_FETCH_OR_N),
CFN_BUILT_IN_ATOMIC_FETCH_OR_1 = int (BUILT_IN_ATOMIC_FETCH_OR_1),
CFN_BUILT_IN_ATOMIC_FETCH_OR_2 = int (BUILT_IN_ATOMIC_FETCH_OR_2),
CFN_BUILT_IN_ATOMIC_FETCH_OR_4 = int (BUILT_IN_ATOMIC_FETCH_OR_4),
CFN_BUILT_IN_ATOMIC_FETCH_OR_8 = int (BUILT_IN_ATOMIC_FETCH_OR_8),
CFN_BUILT_IN_ATOMIC_FETCH_OR_16 = int (BUILT_IN_ATOMIC_FETCH_OR_16),
CFN_BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE = int (BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE),
CFN_BUILT_IN_ATOMIC_IS_LOCK_FREE = int (BUILT_IN_ATOMIC_IS_LOCK_FREE),
CFN_BUILT_IN_ATOMIC_THREAD_FENCE = int (BUILT_IN_ATOMIC_THREAD_FENCE),
CFN_BUILT_IN_ATOMIC_SIGNAL_FENCE = int (BUILT_IN_ATOMIC_SIGNAL_FENCE),
CFN_BUILT_IN_ATOMIC_FERAISEEXCEPT = int (BUILT_IN_ATOMIC_FERAISEEXCEPT),
# 1049 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/omp-builtins.def" 1
# 32 "/home/giulianob/gcc_git_gnu/gcc/gcc/omp-builtins.def"
CFN_BUILT_IN_ACC_GET_DEVICE_TYPE = int (BUILT_IN_ACC_GET_DEVICE_TYPE),
CFN_BUILT_IN_GOACC_DATA_START = int (BUILT_IN_GOACC_DATA_START),
CFN_BUILT_IN_GOACC_DATA_END = int (BUILT_IN_GOACC_DATA_END),
CFN_BUILT_IN_GOACC_ENTER_EXIT_DATA = int (BUILT_IN_GOACC_ENTER_EXIT_DATA),
CFN_BUILT_IN_GOACC_PARALLEL = int (BUILT_IN_GOACC_PARALLEL),
CFN_BUILT_IN_GOACC_UPDATE = int (BUILT_IN_GOACC_UPDATE),
CFN_BUILT_IN_GOACC_WAIT = int (BUILT_IN_GOACC_WAIT),
CFN_BUILT_IN_ACC_ON_DEVICE = int (BUILT_IN_ACC_ON_DEVICE),
CFN_BUILT_IN_GOACC_PARLEVEL_ID = int (BUILT_IN_GOACC_PARLEVEL_ID),
CFN_BUILT_IN_GOACC_PARLEVEL_SIZE = int (BUILT_IN_GOACC_PARLEVEL_SIZE),
CFN_BUILT_IN_OMP_GET_THREAD_NUM = int (BUILT_IN_OMP_GET_THREAD_NUM),
CFN_BUILT_IN_OMP_GET_NUM_THREADS = int (BUILT_IN_OMP_GET_NUM_THREADS),
CFN_BUILT_IN_OMP_GET_TEAM_NUM = int (BUILT_IN_OMP_GET_TEAM_NUM),
CFN_BUILT_IN_OMP_GET_NUM_TEAMS = int (BUILT_IN_OMP_GET_NUM_TEAMS),
CFN_BUILT_IN_GOMP_ATOMIC_START = int (BUILT_IN_GOMP_ATOMIC_START),
CFN_BUILT_IN_GOMP_ATOMIC_END = int (BUILT_IN_GOMP_ATOMIC_END),
CFN_BUILT_IN_GOMP_BARRIER = int (BUILT_IN_GOMP_BARRIER),
CFN_BUILT_IN_GOMP_BARRIER_CANCEL = int (BUILT_IN_GOMP_BARRIER_CANCEL),
CFN_BUILT_IN_GOMP_TASKWAIT = int (BUILT_IN_GOMP_TASKWAIT),
CFN_BUILT_IN_GOMP_TASKWAIT_DEPEND = int (BUILT_IN_GOMP_TASKWAIT_DEPEND),
CFN_BUILT_IN_GOMP_TASKYIELD = int (BUILT_IN_GOMP_TASKYIELD),
CFN_BUILT_IN_GOMP_TASKGROUP_START = int (BUILT_IN_GOMP_TASKGROUP_START),
CFN_BUILT_IN_GOMP_TASKGROUP_END = int (BUILT_IN_GOMP_TASKGROUP_END),
CFN_BUILT_IN_GOMP_CANCEL = int (BUILT_IN_GOMP_CANCEL),
CFN_BUILT_IN_GOMP_CANCELLATION_POINT = int (BUILT_IN_GOMP_CANCELLATION_POINT),
CFN_BUILT_IN_GOMP_CRITICAL_START = int (BUILT_IN_GOMP_CRITICAL_START),
CFN_BUILT_IN_GOMP_CRITICAL_END = int (BUILT_IN_GOMP_CRITICAL_END),
CFN_BUILT_IN_GOMP_CRITICAL_NAME_START = int (BUILT_IN_GOMP_CRITICAL_NAME_START),
CFN_BUILT_IN_GOMP_CRITICAL_NAME_END = int (BUILT_IN_GOMP_CRITICAL_NAME_END),
CFN_BUILT_IN_GOMP_LOOP_STATIC_START = int (BUILT_IN_GOMP_LOOP_STATIC_START),
CFN_BUILT_IN_GOMP_LOOP_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_GUIDED_START = int (BUILT_IN_GOMP_LOOP_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_NONMONOTONIC_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_NONMONOTONIC_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_NONMONOTONIC_GUIDED_START = int (BUILT_IN_GOMP_LOOP_NONMONOTONIC_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_NONMONOTONIC_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_NONMONOTONIC_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_MAYBE_NONMONOTONIC_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_MAYBE_NONMONOTONIC_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_STATIC_START = int (BUILT_IN_GOMP_LOOP_ORDERED_STATIC_START),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_START = int (BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_DOACROSS_STATIC_START = int (BUILT_IN_GOMP_LOOP_DOACROSS_STATIC_START),
CFN_BUILT_IN_GOMP_LOOP_DOACROSS_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_DOACROSS_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_DOACROSS_GUIDED_START = int (BUILT_IN_GOMP_LOOP_DOACROSS_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_DOACROSS_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_DOACROSS_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_START = int (BUILT_IN_GOMP_LOOP_START),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_START = int (BUILT_IN_GOMP_LOOP_ORDERED_START),
CFN_BUILT_IN_GOMP_LOOP_DOACROSS_START = int (BUILT_IN_GOMP_LOOP_DOACROSS_START),
CFN_BUILT_IN_GOMP_LOOP_STATIC_NEXT = int (BUILT_IN_GOMP_LOOP_STATIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_DYNAMIC_NEXT = int (BUILT_IN_GOMP_LOOP_DYNAMIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_GUIDED_NEXT = int (BUILT_IN_GOMP_LOOP_GUIDED_NEXT),
CFN_BUILT_IN_GOMP_LOOP_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_NONMONOTONIC_DYNAMIC_NEXT = int (BUILT_IN_GOMP_LOOP_NONMONOTONIC_DYNAMIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_NONMONOTONIC_GUIDED_NEXT = int (BUILT_IN_GOMP_LOOP_NONMONOTONIC_GUIDED_NEXT),
CFN_BUILT_IN_GOMP_LOOP_NONMONOTONIC_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_NONMONOTONIC_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_MAYBE_NONMONOTONIC_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_MAYBE_NONMONOTONIC_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_STATIC_NEXT = int (BUILT_IN_GOMP_LOOP_ORDERED_STATIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_NEXT = int (BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_NEXT = int (BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_STATIC_START = int (BUILT_IN_GOMP_LOOP_ULL_STATIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_GUIDED_START = int (BUILT_IN_GOMP_LOOP_ULL_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_ULL_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_START = int (BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_START = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_START = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_DOACROSS_STATIC_START = int (BUILT_IN_GOMP_LOOP_ULL_DOACROSS_STATIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_DOACROSS_DYNAMIC_START = int (BUILT_IN_GOMP_LOOP_ULL_DOACROSS_DYNAMIC_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_DOACROSS_GUIDED_START = int (BUILT_IN_GOMP_LOOP_ULL_DOACROSS_GUIDED_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_DOACROSS_RUNTIME_START = int (BUILT_IN_GOMP_LOOP_ULL_DOACROSS_RUNTIME_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_START = int (BUILT_IN_GOMP_LOOP_ULL_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_START = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_DOACROSS_START = int (BUILT_IN_GOMP_LOOP_ULL_DOACROSS_START),
CFN_BUILT_IN_GOMP_LOOP_ULL_STATIC_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_STATIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_GUIDED_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_GUIDED_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_NONMONOTONIC_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT),
CFN_BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT = int (BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_STATIC = int (BUILT_IN_GOMP_PARALLEL_LOOP_STATIC),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_DYNAMIC = int (BUILT_IN_GOMP_PARALLEL_LOOP_DYNAMIC),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_GUIDED = int (BUILT_IN_GOMP_PARALLEL_LOOP_GUIDED),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_RUNTIME = int (BUILT_IN_GOMP_PARALLEL_LOOP_RUNTIME),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_DYNAMIC = int (BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_DYNAMIC),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_GUIDED = int (BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_GUIDED),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_RUNTIME = int (BUILT_IN_GOMP_PARALLEL_LOOP_NONMONOTONIC_RUNTIME),
CFN_BUILT_IN_GOMP_PARALLEL_LOOP_MAYBE_NONMONOTONIC_RUNTIME = int (BUILT_IN_GOMP_PARALLEL_LOOP_MAYBE_NONMONOTONIC_RUNTIME),
CFN_BUILT_IN_GOMP_LOOP_END = int (BUILT_IN_GOMP_LOOP_END),
CFN_BUILT_IN_GOMP_LOOP_END_CANCEL = int (BUILT_IN_GOMP_LOOP_END_CANCEL),
CFN_BUILT_IN_GOMP_LOOP_END_NOWAIT = int (BUILT_IN_GOMP_LOOP_END_NOWAIT),
CFN_BUILT_IN_GOMP_ORDERED_START = int (BUILT_IN_GOMP_ORDERED_START),
CFN_BUILT_IN_GOMP_ORDERED_END = int (BUILT_IN_GOMP_ORDERED_END),
CFN_BUILT_IN_GOMP_DOACROSS_POST = int (BUILT_IN_GOMP_DOACROSS_POST),
CFN_BUILT_IN_GOMP_DOACROSS_WAIT = int (BUILT_IN_GOMP_DOACROSS_WAIT),
CFN_BUILT_IN_GOMP_DOACROSS_ULL_POST = int (BUILT_IN_GOMP_DOACROSS_ULL_POST),
CFN_BUILT_IN_GOMP_DOACROSS_ULL_WAIT = int (BUILT_IN_GOMP_DOACROSS_ULL_WAIT),
CFN_BUILT_IN_GOMP_PARALLEL = int (BUILT_IN_GOMP_PARALLEL),
CFN_BUILT_IN_GOMP_PARALLEL_REDUCTIONS = int (BUILT_IN_GOMP_PARALLEL_REDUCTIONS),
CFN_BUILT_IN_GOMP_TASK = int (BUILT_IN_GOMP_TASK),
CFN_BUILT_IN_GOMP_TASKLOOP = int (BUILT_IN_GOMP_TASKLOOP),
CFN_BUILT_IN_GOMP_TASKLOOP_ULL = int (BUILT_IN_GOMP_TASKLOOP_ULL),
CFN_BUILT_IN_GOMP_SECTIONS_START = int (BUILT_IN_GOMP_SECTIONS_START),
CFN_BUILT_IN_GOMP_SECTIONS2_START = int (BUILT_IN_GOMP_SECTIONS2_START),
CFN_BUILT_IN_GOMP_SECTIONS_NEXT = int (BUILT_IN_GOMP_SECTIONS_NEXT),
CFN_BUILT_IN_GOMP_PARALLEL_SECTIONS = int (BUILT_IN_GOMP_PARALLEL_SECTIONS),
CFN_BUILT_IN_GOMP_SECTIONS_END = int (BUILT_IN_GOMP_SECTIONS_END),
CFN_BUILT_IN_GOMP_SECTIONS_END_CANCEL = int (BUILT_IN_GOMP_SECTIONS_END_CANCEL),
CFN_BUILT_IN_GOMP_SECTIONS_END_NOWAIT = int (BUILT_IN_GOMP_SECTIONS_END_NOWAIT),
CFN_BUILT_IN_GOMP_SINGLE_START = int (BUILT_IN_GOMP_SINGLE_START),
CFN_BUILT_IN_GOMP_SINGLE_COPY_START = int (BUILT_IN_GOMP_SINGLE_COPY_START),
CFN_BUILT_IN_GOMP_SINGLE_COPY_END = int (BUILT_IN_GOMP_SINGLE_COPY_END),
CFN_BUILT_IN_GOMP_OFFLOAD_REGISTER = int (BUILT_IN_GOMP_OFFLOAD_REGISTER),
CFN_BUILT_IN_GOMP_OFFLOAD_UNREGISTER = int (BUILT_IN_GOMP_OFFLOAD_UNREGISTER),
CFN_BUILT_IN_GOMP_TARGET = int (BUILT_IN_GOMP_TARGET),
CFN_BUILT_IN_GOMP_TARGET_DATA = int (BUILT_IN_GOMP_TARGET_DATA),
CFN_BUILT_IN_GOMP_TARGET_END_DATA = int (BUILT_IN_GOMP_TARGET_END_DATA),
CFN_BUILT_IN_GOMP_TARGET_UPDATE = int (BUILT_IN_GOMP_TARGET_UPDATE),
CFN_BUILT_IN_GOMP_TARGET_ENTER_EXIT_DATA = int (BUILT_IN_GOMP_TARGET_ENTER_EXIT_DATA),
CFN_BUILT_IN_GOMP_TEAMS = int (BUILT_IN_GOMP_TEAMS),
CFN_BUILT_IN_GOMP_TEAMS_REG = int (BUILT_IN_GOMP_TEAMS_REG),
CFN_BUILT_IN_GOMP_TASKGROUP_REDUCTION_REGISTER = int (BUILT_IN_GOMP_TASKGROUP_REDUCTION_REGISTER),
CFN_BUILT_IN_GOMP_TASKGROUP_REDUCTION_UNREGISTER = int (BUILT_IN_GOMP_TASKGROUP_REDUCTION_UNREGISTER),
CFN_BUILT_IN_GOMP_TASK_REDUCTION_REMAP = int (BUILT_IN_GOMP_TASK_REDUCTION_REMAP),
CFN_BUILT_IN_GOMP_WORKSHARE_TASK_REDUCTION_UNREGISTER = int (BUILT_IN_GOMP_WORKSHARE_TASK_REDUCTION_UNREGISTER),
CFN_BUILT_IN_GOACC_DECLARE = int (BUILT_IN_GOACC_DECLARE),
# 1052 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/gtm-builtins.def" 1
CFN_BUILT_IN_TM_START = int (BUILT_IN_TM_START),
CFN_BUILT_IN_TM_COMMIT = int (BUILT_IN_TM_COMMIT),
CFN_BUILT_IN_TM_COMMIT_EH = int (BUILT_IN_TM_COMMIT_EH),
CFN_BUILT_IN_TM_ABORT = int (BUILT_IN_TM_ABORT),
CFN_BUILT_IN_TM_IRREVOCABLE = int (BUILT_IN_TM_IRREVOCABLE),
CFN_BUILT_IN_TM_MEMCPY = int (BUILT_IN_TM_MEMCPY),
CFN_BUILT_IN_TM_MEMCPY_RNWT = int (BUILT_IN_TM_MEMCPY_RNWT),
CFN_BUILT_IN_TM_MEMCPY_RTWN = int (BUILT_IN_TM_MEMCPY_RTWN),
CFN_BUILT_IN_TM_MEMMOVE = int (BUILT_IN_TM_MEMMOVE),
CFN_BUILT_IN_TM_MEMSET = int (BUILT_IN_TM_MEMSET),
CFN_BUILT_IN_TM_GETTMCLONE_IRR = int (BUILT_IN_TM_GETTMCLONE_IRR),
CFN_BUILT_IN_TM_GETTMCLONE_SAFE = int (BUILT_IN_TM_GETTMCLONE_SAFE),
CFN_BUILT_IN_TM_MALLOC = int (BUILT_IN_TM_MALLOC),
CFN_BUILT_IN_TM_CALLOC = int (BUILT_IN_TM_CALLOC),
CFN_BUILT_IN_TM_FREE = int (BUILT_IN_TM_FREE),
CFN_BUILT_IN_TM_LOG_1 = int (BUILT_IN_TM_LOG_1),
CFN_BUILT_IN_TM_LOG_2 = int (BUILT_IN_TM_LOG_2),
CFN_BUILT_IN_TM_LOG_4 = int (BUILT_IN_TM_LOG_4),
CFN_BUILT_IN_TM_LOG_8 = int (BUILT_IN_TM_LOG_8),
CFN_BUILT_IN_TM_LOG_FLOAT = int (BUILT_IN_TM_LOG_FLOAT),
CFN_BUILT_IN_TM_LOG_DOUBLE = int (BUILT_IN_TM_LOG_DOUBLE),
CFN_BUILT_IN_TM_LOG_LDOUBLE = int (BUILT_IN_TM_LOG_LDOUBLE),
CFN_BUILT_IN_TM_LOG = int (BUILT_IN_TM_LOG),
CFN_BUILT_IN_TM_LOG_M64 = int (BUILT_IN_TM_LOG_M64),
CFN_BUILT_IN_TM_LOG_M128 = int (BUILT_IN_TM_LOG_M128),
CFN_BUILT_IN_TM_LOG_M256 = int (BUILT_IN_TM_LOG_M256),
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/gtm-builtins.def"
CFN_BUILT_IN_TM_STORE_1 = int (BUILT_IN_TM_STORE_1),
CFN_BUILT_IN_TM_STORE_WAR_1 = int (BUILT_IN_TM_STORE_WAR_1),
CFN_BUILT_IN_TM_STORE_WAW_1 = int (BUILT_IN_TM_STORE_WAW_1),
CFN_BUILT_IN_TM_STORE_2 = int (BUILT_IN_TM_STORE_2),
CFN_BUILT_IN_TM_STORE_WAR_2 = int (BUILT_IN_TM_STORE_WAR_2),
CFN_BUILT_IN_TM_STORE_WAW_2 = int (BUILT_IN_TM_STORE_WAW_2),
CFN_BUILT_IN_TM_STORE_4 = int (BUILT_IN_TM_STORE_4),
CFN_BUILT_IN_TM_STORE_WAR_4 = int (BUILT_IN_TM_STORE_WAR_4),
CFN_BUILT_IN_TM_STORE_WAW_4 = int (BUILT_IN_TM_STORE_WAW_4),
CFN_BUILT_IN_TM_STORE_8 = int (BUILT_IN_TM_STORE_8),
CFN_BUILT_IN_TM_STORE_WAR_8 = int (BUILT_IN_TM_STORE_WAR_8),
CFN_BUILT_IN_TM_STORE_WAW_8 = int (BUILT_IN_TM_STORE_WAW_8),
CFN_BUILT_IN_TM_STORE_FLOAT = int (BUILT_IN_TM_STORE_FLOAT),
CFN_BUILT_IN_TM_STORE_WAR_FLOAT = int (BUILT_IN_TM_STORE_WAR_FLOAT),
CFN_BUILT_IN_TM_STORE_WAW_FLOAT = int (BUILT_IN_TM_STORE_WAW_FLOAT),
CFN_BUILT_IN_TM_STORE_DOUBLE = int (BUILT_IN_TM_STORE_DOUBLE),
CFN_BUILT_IN_TM_STORE_WAR_DOUBLE = int (BUILT_IN_TM_STORE_WAR_DOUBLE),
CFN_BUILT_IN_TM_STORE_WAW_DOUBLE = int (BUILT_IN_TM_STORE_WAW_DOUBLE),
CFN_BUILT_IN_TM_STORE_M64 = int (BUILT_IN_TM_STORE_M64),
CFN_BUILT_IN_TM_STORE_WAR_M64 = int (BUILT_IN_TM_STORE_WAR_M64),
CFN_BUILT_IN_TM_STORE_WAW_M64 = int (BUILT_IN_TM_STORE_WAW_M64),
CFN_BUILT_IN_TM_STORE_M128 = int (BUILT_IN_TM_STORE_M128),
CFN_BUILT_IN_TM_STORE_WAR_M128 = int (BUILT_IN_TM_STORE_WAR_M128),
CFN_BUILT_IN_TM_STORE_WAW_M128 = int (BUILT_IN_TM_STORE_WAW_M128),
CFN_BUILT_IN_TM_STORE_M256 = int (BUILT_IN_TM_STORE_M256),
CFN_BUILT_IN_TM_STORE_WAR_M256 = int (BUILT_IN_TM_STORE_WAR_M256),
CFN_BUILT_IN_TM_STORE_WAW_M256 = int (BUILT_IN_TM_STORE_WAW_M256),
CFN_BUILT_IN_TM_STORE_LDOUBLE = int (BUILT_IN_TM_STORE_LDOUBLE),
CFN_BUILT_IN_TM_STORE_WAR_LDOUBLE = int (BUILT_IN_TM_STORE_WAR_LDOUBLE),
CFN_BUILT_IN_TM_STORE_WAW_LDOUBLE = int (BUILT_IN_TM_STORE_WAW_LDOUBLE),
# 133 "/home/giulianob/gcc_git_gnu/gcc/gcc/gtm-builtins.def"
CFN_BUILT_IN_TM_LOAD_1 = int (BUILT_IN_TM_LOAD_1),
CFN_BUILT_IN_TM_LOAD_RAR_1 = int (BUILT_IN_TM_LOAD_RAR_1),
CFN_BUILT_IN_TM_LOAD_RAW_1 = int (BUILT_IN_TM_LOAD_RAW_1),
CFN_BUILT_IN_TM_LOAD_RFW_1 = int (BUILT_IN_TM_LOAD_RFW_1),
CFN_BUILT_IN_TM_LOAD_2 = int (BUILT_IN_TM_LOAD_2),
CFN_BUILT_IN_TM_LOAD_RAR_2 = int (BUILT_IN_TM_LOAD_RAR_2),
CFN_BUILT_IN_TM_LOAD_RAW_2 = int (BUILT_IN_TM_LOAD_RAW_2),
CFN_BUILT_IN_TM_LOAD_RFW_2 = int (BUILT_IN_TM_LOAD_RFW_2),
CFN_BUILT_IN_TM_LOAD_4 = int (BUILT_IN_TM_LOAD_4),
CFN_BUILT_IN_TM_LOAD_RAR_4 = int (BUILT_IN_TM_LOAD_RAR_4),
CFN_BUILT_IN_TM_LOAD_RAW_4 = int (BUILT_IN_TM_LOAD_RAW_4),
CFN_BUILT_IN_TM_LOAD_RFW_4 = int (BUILT_IN_TM_LOAD_RFW_4),
CFN_BUILT_IN_TM_LOAD_8 = int (BUILT_IN_TM_LOAD_8),
CFN_BUILT_IN_TM_LOAD_RAR_8 = int (BUILT_IN_TM_LOAD_RAR_8),
CFN_BUILT_IN_TM_LOAD_RAW_8 = int (BUILT_IN_TM_LOAD_RAW_8),
CFN_BUILT_IN_TM_LOAD_RFW_8 = int (BUILT_IN_TM_LOAD_RFW_8),
CFN_BUILT_IN_TM_LOAD_FLOAT = int (BUILT_IN_TM_LOAD_FLOAT),
CFN_BUILT_IN_TM_LOAD_RAR_FLOAT = int (BUILT_IN_TM_LOAD_RAR_FLOAT),
CFN_BUILT_IN_TM_LOAD_RAW_FLOAT = int (BUILT_IN_TM_LOAD_RAW_FLOAT),
CFN_BUILT_IN_TM_LOAD_RFW_FLOAT = int (BUILT_IN_TM_LOAD_RFW_FLOAT),
CFN_BUILT_IN_TM_LOAD_DOUBLE = int (BUILT_IN_TM_LOAD_DOUBLE),
CFN_BUILT_IN_TM_LOAD_RAR_DOUBLE = int (BUILT_IN_TM_LOAD_RAR_DOUBLE),
CFN_BUILT_IN_TM_LOAD_RAW_DOUBLE = int (BUILT_IN_TM_LOAD_RAW_DOUBLE),
CFN_BUILT_IN_TM_LOAD_RFW_DOUBLE = int (BUILT_IN_TM_LOAD_RFW_DOUBLE),
CFN_BUILT_IN_TM_LOAD_M64 = int (BUILT_IN_TM_LOAD_M64),
CFN_BUILT_IN_TM_LOAD_RAR_M64 = int (BUILT_IN_TM_LOAD_RAR_M64),
CFN_BUILT_IN_TM_LOAD_RAW_M64 = int (BUILT_IN_TM_LOAD_RAW_M64),
CFN_BUILT_IN_TM_LOAD_RFW_M64 = int (BUILT_IN_TM_LOAD_RFW_M64),
CFN_BUILT_IN_TM_LOAD_M128 = int (BUILT_IN_TM_LOAD_M128),
CFN_BUILT_IN_TM_LOAD_RAR_M128 = int (BUILT_IN_TM_LOAD_RAR_M128),
CFN_BUILT_IN_TM_LOAD_RAW_M128 = int (BUILT_IN_TM_LOAD_RAW_M128),
CFN_BUILT_IN_TM_LOAD_RFW_M128 = int (BUILT_IN_TM_LOAD_RFW_M128),
CFN_BUILT_IN_TM_LOAD_M256 = int (BUILT_IN_TM_LOAD_M256),
CFN_BUILT_IN_TM_LOAD_RAR_M256 = int (BUILT_IN_TM_LOAD_RAR_M256),
CFN_BUILT_IN_TM_LOAD_RAW_M256 = int (BUILT_IN_TM_LOAD_RAW_M256),
CFN_BUILT_IN_TM_LOAD_RFW_M256 = int (BUILT_IN_TM_LOAD_RFW_M256),
CFN_BUILT_IN_TM_LOAD_LDOUBLE = int (BUILT_IN_TM_LOAD_LDOUBLE),
CFN_BUILT_IN_TM_LOAD_RAR_LDOUBLE = int (BUILT_IN_TM_LOAD_RAR_LDOUBLE),
CFN_BUILT_IN_TM_LOAD_RAW_LDOUBLE = int (BUILT_IN_TM_LOAD_RAW_LDOUBLE),
CFN_BUILT_IN_TM_LOAD_RFW_LDOUBLE = int (BUILT_IN_TM_LOAD_RFW_LDOUBLE),
# 1055 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/sanitizer.def" 1
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/sanitizer.def"
CFN_BEGIN_SANITIZER_BUILTINS = int (BEGIN_SANITIZER_BUILTINS),
CFN_BUILT_IN_ASAN_INIT = int (BUILT_IN_ASAN_INIT),
CFN_BUILT_IN_ASAN_VERSION_MISMATCH_CHECK = int (BUILT_IN_ASAN_VERSION_MISMATCH_CHECK),
CFN_BUILT_IN_ASAN_REPORT_LOAD1 = int (BUILT_IN_ASAN_REPORT_LOAD1),
CFN_BUILT_IN_ASAN_REPORT_LOAD2 = int (BUILT_IN_ASAN_REPORT_LOAD2),
CFN_BUILT_IN_ASAN_REPORT_LOAD4 = int (BUILT_IN_ASAN_REPORT_LOAD4),
CFN_BUILT_IN_ASAN_REPORT_LOAD8 = int (BUILT_IN_ASAN_REPORT_LOAD8),
CFN_BUILT_IN_ASAN_REPORT_LOAD16 = int (BUILT_IN_ASAN_REPORT_LOAD16),
CFN_BUILT_IN_ASAN_REPORT_LOAD_N = int (BUILT_IN_ASAN_REPORT_LOAD_N),
CFN_BUILT_IN_ASAN_REPORT_STORE1 = int (BUILT_IN_ASAN_REPORT_STORE1),
CFN_BUILT_IN_ASAN_REPORT_STORE2 = int (BUILT_IN_ASAN_REPORT_STORE2),
CFN_BUILT_IN_ASAN_REPORT_STORE4 = int (BUILT_IN_ASAN_REPORT_STORE4),
CFN_BUILT_IN_ASAN_REPORT_STORE8 = int (BUILT_IN_ASAN_REPORT_STORE8),
CFN_BUILT_IN_ASAN_REPORT_STORE16 = int (BUILT_IN_ASAN_REPORT_STORE16),
CFN_BUILT_IN_ASAN_REPORT_STORE_N = int (BUILT_IN_ASAN_REPORT_STORE_N),
CFN_BUILT_IN_ASAN_REPORT_LOAD1_NOABORT = int (BUILT_IN_ASAN_REPORT_LOAD1_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_LOAD2_NOABORT = int (BUILT_IN_ASAN_REPORT_LOAD2_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_LOAD4_NOABORT = int (BUILT_IN_ASAN_REPORT_LOAD4_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_LOAD8_NOABORT = int (BUILT_IN_ASAN_REPORT_LOAD8_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_LOAD16_NOABORT = int (BUILT_IN_ASAN_REPORT_LOAD16_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_LOAD_N_NOABORT = int (BUILT_IN_ASAN_REPORT_LOAD_N_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_STORE1_NOABORT = int (BUILT_IN_ASAN_REPORT_STORE1_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_STORE2_NOABORT = int (BUILT_IN_ASAN_REPORT_STORE2_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_STORE4_NOABORT = int (BUILT_IN_ASAN_REPORT_STORE4_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_STORE8_NOABORT = int (BUILT_IN_ASAN_REPORT_STORE8_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_STORE16_NOABORT = int (BUILT_IN_ASAN_REPORT_STORE16_NOABORT),
CFN_BUILT_IN_ASAN_REPORT_STORE_N_NOABORT = int (BUILT_IN_ASAN_REPORT_STORE_N_NOABORT),
CFN_BUILT_IN_ASAN_LOAD1 = int (BUILT_IN_ASAN_LOAD1),
CFN_BUILT_IN_ASAN_LOAD2 = int (BUILT_IN_ASAN_LOAD2),
CFN_BUILT_IN_ASAN_LOAD4 = int (BUILT_IN_ASAN_LOAD4),
CFN_BUILT_IN_ASAN_LOAD8 = int (BUILT_IN_ASAN_LOAD8),
CFN_BUILT_IN_ASAN_LOAD16 = int (BUILT_IN_ASAN_LOAD16),
CFN_BUILT_IN_ASAN_LOADN = int (BUILT_IN_ASAN_LOADN),
CFN_BUILT_IN_ASAN_STORE1 = int (BUILT_IN_ASAN_STORE1),
CFN_BUILT_IN_ASAN_STORE2 = int (BUILT_IN_ASAN_STORE2),
CFN_BUILT_IN_ASAN_STORE4 = int (BUILT_IN_ASAN_STORE4),
CFN_BUILT_IN_ASAN_STORE8 = int (BUILT_IN_ASAN_STORE8),
CFN_BUILT_IN_ASAN_STORE16 = int (BUILT_IN_ASAN_STORE16),
CFN_BUILT_IN_ASAN_STOREN = int (BUILT_IN_ASAN_STOREN),
CFN_BUILT_IN_ASAN_LOAD1_NOABORT = int (BUILT_IN_ASAN_LOAD1_NOABORT),
CFN_BUILT_IN_ASAN_LOAD2_NOABORT = int (BUILT_IN_ASAN_LOAD2_NOABORT),
CFN_BUILT_IN_ASAN_LOAD4_NOABORT = int (BUILT_IN_ASAN_LOAD4_NOABORT),
CFN_BUILT_IN_ASAN_LOAD8_NOABORT = int (BUILT_IN_ASAN_LOAD8_NOABORT),
CFN_BUILT_IN_ASAN_LOAD16_NOABORT = int (BUILT_IN_ASAN_LOAD16_NOABORT),
CFN_BUILT_IN_ASAN_LOADN_NOABORT = int (BUILT_IN_ASAN_LOADN_NOABORT),
CFN_BUILT_IN_ASAN_STORE1_NOABORT = int (BUILT_IN_ASAN_STORE1_NOABORT),
CFN_BUILT_IN_ASAN_STORE2_NOABORT = int (BUILT_IN_ASAN_STORE2_NOABORT),
CFN_BUILT_IN_ASAN_STORE4_NOABORT = int (BUILT_IN_ASAN_STORE4_NOABORT),
CFN_BUILT_IN_ASAN_STORE8_NOABORT = int (BUILT_IN_ASAN_STORE8_NOABORT),
CFN_BUILT_IN_ASAN_STORE16_NOABORT = int (BUILT_IN_ASAN_STORE16_NOABORT),
CFN_BUILT_IN_ASAN_STOREN_NOABORT = int (BUILT_IN_ASAN_STOREN_NOABORT),
CFN_BUILT_IN_ASAN_REGISTER_GLOBALS = int (BUILT_IN_ASAN_REGISTER_GLOBALS),
CFN_BUILT_IN_ASAN_UNREGISTER_GLOBALS = int (BUILT_IN_ASAN_UNREGISTER_GLOBALS),
CFN_BUILT_IN_ASAN_HANDLE_NO_RETURN = int (BUILT_IN_ASAN_HANDLE_NO_RETURN),
CFN_BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT = int (BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT),
CFN_BUILT_IN_ASAN_AFTER_DYNAMIC_INIT = int (BUILT_IN_ASAN_AFTER_DYNAMIC_INIT),
CFN_BUILT_IN_ASAN_POISON_STACK_MEMORY = int (BUILT_IN_ASAN_POISON_STACK_MEMORY),
CFN_BUILT_IN_ASAN_UNPOISON_STACK_MEMORY = int (BUILT_IN_ASAN_UNPOISON_STACK_MEMORY),
CFN_BUILT_IN_ASAN_ALLOCA_POISON = int (BUILT_IN_ASAN_ALLOCA_POISON),
CFN_BUILT_IN_ASAN_ALLOCAS_UNPOISON = int (BUILT_IN_ASAN_ALLOCAS_UNPOISON),
CFN_BUILT_IN_ASAN_POINTER_COMPARE = int (BUILT_IN_ASAN_POINTER_COMPARE),
CFN_BUILT_IN_ASAN_POINTER_SUBTRACT = int (BUILT_IN_ASAN_POINTER_SUBTRACT),
CFN_BUILT_IN_TSAN_INIT = int (BUILT_IN_TSAN_INIT),
CFN_BUILT_IN_TSAN_FUNC_ENTRY = int (BUILT_IN_TSAN_FUNC_ENTRY),
CFN_BUILT_IN_TSAN_FUNC_EXIT = int (BUILT_IN_TSAN_FUNC_EXIT),
CFN_BUILT_IN_TSAN_VPTR_UPDATE = int (BUILT_IN_TSAN_VPTR_UPDATE),
CFN_BUILT_IN_TSAN_READ1 = int (BUILT_IN_TSAN_READ1),
CFN_BUILT_IN_TSAN_READ2 = int (BUILT_IN_TSAN_READ2),
CFN_BUILT_IN_TSAN_READ4 = int (BUILT_IN_TSAN_READ4),
CFN_BUILT_IN_TSAN_READ8 = int (BUILT_IN_TSAN_READ8),
CFN_BUILT_IN_TSAN_READ16 = int (BUILT_IN_TSAN_READ16),
CFN_BUILT_IN_TSAN_WRITE1 = int (BUILT_IN_TSAN_WRITE1),
CFN_BUILT_IN_TSAN_WRITE2 = int (BUILT_IN_TSAN_WRITE2),
CFN_BUILT_IN_TSAN_WRITE4 = int (BUILT_IN_TSAN_WRITE4),
CFN_BUILT_IN_TSAN_WRITE8 = int (BUILT_IN_TSAN_WRITE8),
CFN_BUILT_IN_TSAN_WRITE16 = int (BUILT_IN_TSAN_WRITE16),
CFN_BUILT_IN_TSAN_READ_RANGE = int (BUILT_IN_TSAN_READ_RANGE),
CFN_BUILT_IN_TSAN_WRITE_RANGE = int (BUILT_IN_TSAN_WRITE_RANGE),
CFN_BUILT_IN_TSAN_VOLATILE_READ1 = int (BUILT_IN_TSAN_VOLATILE_READ1),
CFN_BUILT_IN_TSAN_VOLATILE_READ2 = int (BUILT_IN_TSAN_VOLATILE_READ2),
CFN_BUILT_IN_TSAN_VOLATILE_READ4 = int (BUILT_IN_TSAN_VOLATILE_READ4),
CFN_BUILT_IN_TSAN_VOLATILE_READ8 = int (BUILT_IN_TSAN_VOLATILE_READ8),
CFN_BUILT_IN_TSAN_VOLATILE_READ16 = int (BUILT_IN_TSAN_VOLATILE_READ16),
CFN_BUILT_IN_TSAN_VOLATILE_WRITE1 = int (BUILT_IN_TSAN_VOLATILE_WRITE1),
CFN_BUILT_IN_TSAN_VOLATILE_WRITE2 = int (BUILT_IN_TSAN_VOLATILE_WRITE2),
CFN_BUILT_IN_TSAN_VOLATILE_WRITE4 = int (BUILT_IN_TSAN_VOLATILE_WRITE4),
CFN_BUILT_IN_TSAN_VOLATILE_WRITE8 = int (BUILT_IN_TSAN_VOLATILE_WRITE8),
CFN_BUILT_IN_TSAN_VOLATILE_WRITE16 = int (BUILT_IN_TSAN_VOLATILE_WRITE16),
CFN_BUILT_IN_TSAN_ATOMIC8_LOAD = int (BUILT_IN_TSAN_ATOMIC8_LOAD),
CFN_BUILT_IN_TSAN_ATOMIC16_LOAD = int (BUILT_IN_TSAN_ATOMIC16_LOAD),
CFN_BUILT_IN_TSAN_ATOMIC32_LOAD = int (BUILT_IN_TSAN_ATOMIC32_LOAD),
CFN_BUILT_IN_TSAN_ATOMIC64_LOAD = int (BUILT_IN_TSAN_ATOMIC64_LOAD),
CFN_BUILT_IN_TSAN_ATOMIC128_LOAD = int (BUILT_IN_TSAN_ATOMIC128_LOAD),
CFN_BUILT_IN_TSAN_ATOMIC8_STORE = int (BUILT_IN_TSAN_ATOMIC8_STORE),
CFN_BUILT_IN_TSAN_ATOMIC16_STORE = int (BUILT_IN_TSAN_ATOMIC16_STORE),
CFN_BUILT_IN_TSAN_ATOMIC32_STORE = int (BUILT_IN_TSAN_ATOMIC32_STORE),
CFN_BUILT_IN_TSAN_ATOMIC64_STORE = int (BUILT_IN_TSAN_ATOMIC64_STORE),
CFN_BUILT_IN_TSAN_ATOMIC128_STORE = int (BUILT_IN_TSAN_ATOMIC128_STORE),
CFN_BUILT_IN_TSAN_ATOMIC8_EXCHANGE = int (BUILT_IN_TSAN_ATOMIC8_EXCHANGE),
CFN_BUILT_IN_TSAN_ATOMIC16_EXCHANGE = int (BUILT_IN_TSAN_ATOMIC16_EXCHANGE),
CFN_BUILT_IN_TSAN_ATOMIC32_EXCHANGE = int (BUILT_IN_TSAN_ATOMIC32_EXCHANGE),
CFN_BUILT_IN_TSAN_ATOMIC64_EXCHANGE = int (BUILT_IN_TSAN_ATOMIC64_EXCHANGE),
CFN_BUILT_IN_TSAN_ATOMIC128_EXCHANGE = int (BUILT_IN_TSAN_ATOMIC128_EXCHANGE),
CFN_BUILT_IN_TSAN_ATOMIC8_FETCH_ADD = int (BUILT_IN_TSAN_ATOMIC8_FETCH_ADD),
CFN_BUILT_IN_TSAN_ATOMIC16_FETCH_ADD = int (BUILT_IN_TSAN_ATOMIC16_FETCH_ADD),
CFN_BUILT_IN_TSAN_ATOMIC32_FETCH_ADD = int (BUILT_IN_TSAN_ATOMIC32_FETCH_ADD),
CFN_BUILT_IN_TSAN_ATOMIC64_FETCH_ADD = int (BUILT_IN_TSAN_ATOMIC64_FETCH_ADD),
CFN_BUILT_IN_TSAN_ATOMIC128_FETCH_ADD = int (BUILT_IN_TSAN_ATOMIC128_FETCH_ADD),
CFN_BUILT_IN_TSAN_ATOMIC8_FETCH_SUB = int (BUILT_IN_TSAN_ATOMIC8_FETCH_SUB),
CFN_BUILT_IN_TSAN_ATOMIC16_FETCH_SUB = int (BUILT_IN_TSAN_ATOMIC16_FETCH_SUB),
CFN_BUILT_IN_TSAN_ATOMIC32_FETCH_SUB = int (BUILT_IN_TSAN_ATOMIC32_FETCH_SUB),
CFN_BUILT_IN_TSAN_ATOMIC64_FETCH_SUB = int (BUILT_IN_TSAN_ATOMIC64_FETCH_SUB),
CFN_BUILT_IN_TSAN_ATOMIC128_FETCH_SUB = int (BUILT_IN_TSAN_ATOMIC128_FETCH_SUB),
CFN_BUILT_IN_TSAN_ATOMIC8_FETCH_AND = int (BUILT_IN_TSAN_ATOMIC8_FETCH_AND),
CFN_BUILT_IN_TSAN_ATOMIC16_FETCH_AND = int (BUILT_IN_TSAN_ATOMIC16_FETCH_AND),
CFN_BUILT_IN_TSAN_ATOMIC32_FETCH_AND = int (BUILT_IN_TSAN_ATOMIC32_FETCH_AND),
CFN_BUILT_IN_TSAN_ATOMIC64_FETCH_AND = int (BUILT_IN_TSAN_ATOMIC64_FETCH_AND),
CFN_BUILT_IN_TSAN_ATOMIC128_FETCH_AND = int (BUILT_IN_TSAN_ATOMIC128_FETCH_AND),
CFN_BUILT_IN_TSAN_ATOMIC8_FETCH_OR = int (BUILT_IN_TSAN_ATOMIC8_FETCH_OR),
CFN_BUILT_IN_TSAN_ATOMIC16_FETCH_OR = int (BUILT_IN_TSAN_ATOMIC16_FETCH_OR),
CFN_BUILT_IN_TSAN_ATOMIC32_FETCH_OR = int (BUILT_IN_TSAN_ATOMIC32_FETCH_OR),
CFN_BUILT_IN_TSAN_ATOMIC64_FETCH_OR = int (BUILT_IN_TSAN_ATOMIC64_FETCH_OR),
CFN_BUILT_IN_TSAN_ATOMIC128_FETCH_OR = int (BUILT_IN_TSAN_ATOMIC128_FETCH_OR),
CFN_BUILT_IN_TSAN_ATOMIC8_FETCH_XOR = int (BUILT_IN_TSAN_ATOMIC8_FETCH_XOR),
CFN_BUILT_IN_TSAN_ATOMIC16_FETCH_XOR = int (BUILT_IN_TSAN_ATOMIC16_FETCH_XOR),
CFN_BUILT_IN_TSAN_ATOMIC32_FETCH_XOR = int (BUILT_IN_TSAN_ATOMIC32_FETCH_XOR),
CFN_BUILT_IN_TSAN_ATOMIC64_FETCH_XOR = int (BUILT_IN_TSAN_ATOMIC64_FETCH_XOR),
CFN_BUILT_IN_TSAN_ATOMIC128_FETCH_XOR = int (BUILT_IN_TSAN_ATOMIC128_FETCH_XOR),
CFN_BUILT_IN_TSAN_ATOMIC8_FETCH_NAND = int (BUILT_IN_TSAN_ATOMIC8_FETCH_NAND),
CFN_BUILT_IN_TSAN_ATOMIC16_FETCH_NAND = int (BUILT_IN_TSAN_ATOMIC16_FETCH_NAND),
CFN_BUILT_IN_TSAN_ATOMIC32_FETCH_NAND = int (BUILT_IN_TSAN_ATOMIC32_FETCH_NAND),
CFN_BUILT_IN_TSAN_ATOMIC64_FETCH_NAND = int (BUILT_IN_TSAN_ATOMIC64_FETCH_NAND),
CFN_BUILT_IN_TSAN_ATOMIC128_FETCH_NAND = int (BUILT_IN_TSAN_ATOMIC128_FETCH_NAND),
CFN_BUILT_IN_TSAN_ATOMIC8_COMPARE_EXCHANGE_STRONG = int (BUILT_IN_TSAN_ATOMIC8_COMPARE_EXCHANGE_STRONG),
CFN_BUILT_IN_TSAN_ATOMIC16_COMPARE_EXCHANGE_STRONG = int (BUILT_IN_TSAN_ATOMIC16_COMPARE_EXCHANGE_STRONG),
CFN_BUILT_IN_TSAN_ATOMIC32_COMPARE_EXCHANGE_STRONG = int (BUILT_IN_TSAN_ATOMIC32_COMPARE_EXCHANGE_STRONG),
CFN_BUILT_IN_TSAN_ATOMIC64_COMPARE_EXCHANGE_STRONG = int (BUILT_IN_TSAN_ATOMIC64_COMPARE_EXCHANGE_STRONG),
CFN_BUILT_IN_TSAN_ATOMIC128_COMPARE_EXCHANGE_STRONG = int (BUILT_IN_TSAN_ATOMIC128_COMPARE_EXCHANGE_STRONG),
CFN_BUILT_IN_TSAN_ATOMIC8_COMPARE_EXCHANGE_WEAK = int (BUILT_IN_TSAN_ATOMIC8_COMPARE_EXCHANGE_WEAK),
CFN_BUILT_IN_TSAN_ATOMIC16_COMPARE_EXCHANGE_WEAK = int (BUILT_IN_TSAN_ATOMIC16_COMPARE_EXCHANGE_WEAK),
CFN_BUILT_IN_TSAN_ATOMIC32_COMPARE_EXCHANGE_WEAK = int (BUILT_IN_TSAN_ATOMIC32_COMPARE_EXCHANGE_WEAK),
CFN_BUILT_IN_TSAN_ATOMIC64_COMPARE_EXCHANGE_WEAK = int (BUILT_IN_TSAN_ATOMIC64_COMPARE_EXCHANGE_WEAK),
CFN_BUILT_IN_TSAN_ATOMIC128_COMPARE_EXCHANGE_WEAK = int (BUILT_IN_TSAN_ATOMIC128_COMPARE_EXCHANGE_WEAK),
CFN_BUILT_IN_TSAN_ATOMIC_THREAD_FENCE = int (BUILT_IN_TSAN_ATOMIC_THREAD_FENCE),
CFN_BUILT_IN_TSAN_ATOMIC_SIGNAL_FENCE = int (BUILT_IN_TSAN_ATOMIC_SIGNAL_FENCE),
CFN_BUILT_IN_UBSAN_HANDLE_DIVREM_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_DIVREM_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_SHIFT_OUT_OF_BOUNDS = int (BUILT_IN_UBSAN_HANDLE_SHIFT_OUT_OF_BOUNDS),
CFN_BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE = int (BUILT_IN_UBSAN_HANDLE_BUILTIN_UNREACHABLE),
CFN_BUILT_IN_UBSAN_HANDLE_MISSING_RETURN = int (BUILT_IN_UBSAN_HANDLE_MISSING_RETURN),
CFN_BUILT_IN_UBSAN_HANDLE_VLA_BOUND_NOT_POSITIVE = int (BUILT_IN_UBSAN_HANDLE_VLA_BOUND_NOT_POSITIVE),
CFN_BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_V1 = int (BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_V1),
CFN_BUILT_IN_UBSAN_HANDLE_ADD_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_ADD_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_SUB_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_SUB_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_MUL_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_MUL_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_NEGATE_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_NEGATE_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_LOAD_INVALID_VALUE = int (BUILT_IN_UBSAN_HANDLE_LOAD_INVALID_VALUE),
CFN_BUILT_IN_UBSAN_HANDLE_POINTER_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_POINTER_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_DIVREM_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_DIVREM_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_SHIFT_OUT_OF_BOUNDS_ABORT = int (BUILT_IN_UBSAN_HANDLE_SHIFT_OUT_OF_BOUNDS_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_VLA_BOUND_NOT_POSITIVE_ABORT = int (BUILT_IN_UBSAN_HANDLE_VLA_BOUND_NOT_POSITIVE_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_V1_ABORT = int (BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_V1_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_ADD_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_ADD_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_SUB_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_SUB_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_MUL_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_MUL_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_NEGATE_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_NEGATE_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_LOAD_INVALID_VALUE_ABORT = int (BUILT_IN_UBSAN_HANDLE_LOAD_INVALID_VALUE_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_POINTER_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_POINTER_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_FLOAT_CAST_OVERFLOW = int (BUILT_IN_UBSAN_HANDLE_FLOAT_CAST_OVERFLOW),
CFN_BUILT_IN_UBSAN_HANDLE_FLOAT_CAST_OVERFLOW_ABORT = int (BUILT_IN_UBSAN_HANDLE_FLOAT_CAST_OVERFLOW_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS = int (BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS),
CFN_BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS_ABORT = int (BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_NONNULL_ARG = int (BUILT_IN_UBSAN_HANDLE_NONNULL_ARG),
CFN_BUILT_IN_UBSAN_HANDLE_NONNULL_ARG_ABORT = int (BUILT_IN_UBSAN_HANDLE_NONNULL_ARG_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_NONNULL_RETURN_V1 = int (BUILT_IN_UBSAN_HANDLE_NONNULL_RETURN_V1),
CFN_BUILT_IN_UBSAN_HANDLE_NONNULL_RETURN_V1_ABORT = int (BUILT_IN_UBSAN_HANDLE_NONNULL_RETURN_V1_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_INVALID_BUILTIN = int (BUILT_IN_UBSAN_HANDLE_INVALID_BUILTIN),
CFN_BUILT_IN_UBSAN_HANDLE_INVALID_BUILTIN_ABORT = int (BUILT_IN_UBSAN_HANDLE_INVALID_BUILTIN_ABORT),
CFN_BUILT_IN_UBSAN_HANDLE_DYNAMIC_TYPE_CACHE_MISS = int (BUILT_IN_UBSAN_HANDLE_DYNAMIC_TYPE_CACHE_MISS),
CFN_BUILT_IN_UBSAN_HANDLE_DYNAMIC_TYPE_CACHE_MISS_ABORT = int (BUILT_IN_UBSAN_HANDLE_DYNAMIC_TYPE_CACHE_MISS_ABORT),
CFN_BUILT_IN_SANITIZER_COV_TRACE_PC = int (BUILT_IN_SANITIZER_COV_TRACE_PC),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CMP1 = int (BUILT_IN_SANITIZER_COV_TRACE_CMP1),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CMP2 = int (BUILT_IN_SANITIZER_COV_TRACE_CMP2),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CMP4 = int (BUILT_IN_SANITIZER_COV_TRACE_CMP4),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CMP8 = int (BUILT_IN_SANITIZER_COV_TRACE_CMP8),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP1 = int (BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP1),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP2 = int (BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP2),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP4 = int (BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP4),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP8 = int (BUILT_IN_SANITIZER_COV_TRACE_CONST_CMP8),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CMPF = int (BUILT_IN_SANITIZER_COV_TRACE_CMPF),
CFN_BUILT_IN_SANITIZER_COV_TRACE_CMPD = int (BUILT_IN_SANITIZER_COV_TRACE_CMPD),
CFN_BUILT_IN_SANITIZER_COV_TRACE_SWITCH = int (BUILT_IN_SANITIZER_COV_TRACE_SWITCH),
CFN_END_SANITIZER_BUILTINS = int (END_SANITIZER_BUILTINS),
# 1058 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/coroutine-builtins.def" 1
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/coroutine-builtins.def"
CFN_BEGIN_COROUTINE_BUILTINS = int (BEGIN_COROUTINE_BUILTINS),
CFN_BUILT_IN_CORO_PROMISE = int (BUILT_IN_CORO_PROMISE),
CFN_BUILT_IN_CORO_RESUME = int (BUILT_IN_CORO_RESUME),
CFN_BUILT_IN_CORO_DESTROY = int (BUILT_IN_CORO_DESTROY),
CFN_BUILT_IN_CORO_DONE = int (BUILT_IN_CORO_DONE),
CFN_END_COROUTINE_BUILTINS = int (END_COROUTINE_BUILTINS),
# 1061 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 1103 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def" 1
# 38 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def"
CFN_BUILT_IN_HSAIL_WORKITEMABSID = int (BUILT_IN_HSAIL_WORKITEMABSID),
CFN_BUILT_IN_HSAIL_GRIDSIZE = int (BUILT_IN_HSAIL_GRIDSIZE),
CFN_BUILT_IN_HSAIL_WORKITEMFLATABSID_U32 = int (BUILT_IN_HSAIL_WORKITEMFLATABSID_U32),
CFN_BUILT_IN_HSAIL_WORKITEMFLATABSID_U64 = int (BUILT_IN_HSAIL_WORKITEMFLATABSID_U64),
CFN_BUILT_IN_HSAIL_WORKITEMFLATID = int (BUILT_IN_HSAIL_WORKITEMFLATID),
CFN_BUILT_IN_HSAIL_WORKITEMID = int (BUILT_IN_HSAIL_WORKITEMID),
CFN_BUILT_IN_HSAIL_WORKGROUPID = int (BUILT_IN_HSAIL_WORKGROUPID),
CFN_BUILT_IN_HSAIL_CURRENTWORKITEMFLATID = int (BUILT_IN_HSAIL_CURRENTWORKITEMFLATID),
CFN_BUILT_IN_HSAIL_WORKITEMABSID_U64 = int (BUILT_IN_HSAIL_WORKITEMABSID_U64),
CFN_BUILT_IN_HSAIL_PACKETID = int (BUILT_IN_HSAIL_PACKETID),
CFN_BUILT_IN_HSAIL_PACKETCOMPLETIONSIG_SIG64 = int (BUILT_IN_HSAIL_PACKETCOMPLETIONSIG_SIG64),
CFN_BUILT_IN_HSAIL_PACKETCOMPLETIONSIG_SIG32 = int (BUILT_IN_HSAIL_PACKETCOMPLETIONSIG_SIG32),
CFN_BUILT_IN_HSAIL_CURRENTWORKGROUPSIZE = int (BUILT_IN_HSAIL_CURRENTWORKGROUPSIZE),
CFN_BUILT_IN_HSAIL_WORKGROUPSIZE = int (BUILT_IN_HSAIL_WORKGROUPSIZE),
CFN_BUILT_IN_HSAIL_DIM = int (BUILT_IN_HSAIL_DIM),
CFN_BUILT_IN_HSAIL_GRIDGROUPS = int (BUILT_IN_HSAIL_GRIDGROUPS),
CFN_BUILT_IN_HSAIL_BITEXTRACT_S32 = int (BUILT_IN_HSAIL_BITEXTRACT_S32),
CFN_BUILT_IN_HSAIL_BITEXTRACT_U32 = int (BUILT_IN_HSAIL_BITEXTRACT_U32),
CFN_BUILT_IN_HSAIL_BITEXTRACT_S64 = int (BUILT_IN_HSAIL_BITEXTRACT_S64),
CFN_BUILT_IN_HSAIL_BITEXTRACT_U64 = int (BUILT_IN_HSAIL_BITEXTRACT_U64),
CFN_BUILT_IN_HSAIL_BITINSERT_U32 = int (BUILT_IN_HSAIL_BITINSERT_U32),
CFN_BUILT_IN_HSAIL_BITINSERT_U64 = int (BUILT_IN_HSAIL_BITINSERT_U64),
CFN_BUILT_IN_HSAIL_BITMASK_B32 = int (BUILT_IN_HSAIL_BITMASK_B32),
CFN_BUILT_IN_HSAIL_BITMASK_B64 = int (BUILT_IN_HSAIL_BITMASK_B64),
CFN_BUILT_IN_HSAIL_BITREV_B32 = int (BUILT_IN_HSAIL_BITREV_B32),
CFN_BUILT_IN_HSAIL_BITREV_B64 = int (BUILT_IN_HSAIL_BITREV_B64),
CFN_BUILT_IN_HSAIL_BITSELECT_B32 = int (BUILT_IN_HSAIL_BITSELECT_B32),
CFN_BUILT_IN_HSAIL_BITSELECT_U64 = int (BUILT_IN_HSAIL_BITSELECT_U64),
CFN_BUILT_IN_HSAIL_FIRSTBIT_U32 = int (BUILT_IN_HSAIL_FIRSTBIT_U32),
CFN_BUILT_IN_HSAIL_FIRSTBIT_S32 = int (BUILT_IN_HSAIL_FIRSTBIT_S32),
CFN_BUILT_IN_HSAIL_FIRSTBIT_U64 = int (BUILT_IN_HSAIL_FIRSTBIT_U64),
CFN_BUILT_IN_HSAIL_FIRSTBIT_S64 = int (BUILT_IN_HSAIL_FIRSTBIT_S64),
CFN_BUILT_IN_HSAIL_LASTBIT_U32 = int (BUILT_IN_HSAIL_LASTBIT_U32),
CFN_BUILT_IN_HSAIL_LASTBIT_U64 = int (BUILT_IN_HSAIL_LASTBIT_U64),
CFN_BUILT_IN_HSAIL_BORROW_U32 = int (BUILT_IN_HSAIL_BORROW_U32),
CFN_BUILT_IN_HSAIL_BORROW_U64 = int (BUILT_IN_HSAIL_BORROW_U64),
CFN_BUILT_IN_HSAIL_CARRY_U32 = int (BUILT_IN_HSAIL_CARRY_U32),
CFN_BUILT_IN_HSAIL_CARRY_U64 = int (BUILT_IN_HSAIL_CARRY_U64),
CFN_BUILT_IN_HSAIL_REM_S32 = int (BUILT_IN_HSAIL_REM_S32),
CFN_BUILT_IN_HSAIL_REM_S64 = int (BUILT_IN_HSAIL_REM_S64),
CFN_BUILT_IN_HSAIL_MIN_F32 = int (BUILT_IN_HSAIL_MIN_F32),
CFN_BUILT_IN_HSAIL_MAX_F32 = int (BUILT_IN_HSAIL_MAX_F32),
CFN_BUILT_IN_HSAIL_MIN_F64 = int (BUILT_IN_HSAIL_MIN_F64),
CFN_BUILT_IN_HSAIL_MAX_F64 = int (BUILT_IN_HSAIL_MAX_F64),
CFN_BUILT_IN_HSAIL_CLASS_F32 = int (BUILT_IN_HSAIL_CLASS_F32),
CFN_BUILT_IN_HSAIL_CLASS_F64 = int (BUILT_IN_HSAIL_CLASS_F64),
CFN_BUILT_IN_HSAIL_CLASS_F32_F16 = int (BUILT_IN_HSAIL_CLASS_F32_F16),
CFN_BUILT_IN_HSAIL_FRACT_F32 = int (BUILT_IN_HSAIL_FRACT_F32),
CFN_BUILT_IN_HSAIL_FRACT_F64 = int (BUILT_IN_HSAIL_FRACT_F64),
CFN_BUILT_IN_HSAIL_BARRIER = int (BUILT_IN_HSAIL_BARRIER),
CFN_BUILT_IN_HSAIL_INITFBAR = int (BUILT_IN_HSAIL_INITFBAR),
CFN_BUILT_IN_HSAIL_JOINFBAR = int (BUILT_IN_HSAIL_JOINFBAR),
CFN_BUILT_IN_HSAIL_WAITFBAR = int (BUILT_IN_HSAIL_WAITFBAR),
CFN_BUILT_IN_HSAIL_ARRIVEFBAR = int (BUILT_IN_HSAIL_ARRIVEFBAR),
CFN_BUILT_IN_HSAIL_LEAVEFBAR = int (BUILT_IN_HSAIL_LEAVEFBAR),
CFN_BUILT_IN_HSAIL_RELEASEFBAR = int (BUILT_IN_HSAIL_RELEASEFBAR),
CFN_BUILT_IN_HSAIL_BITALIGN = int (BUILT_IN_HSAIL_BITALIGN),
CFN_BUILT_IN_HSAIL_BYTEALIGN = int (BUILT_IN_HSAIL_BYTEALIGN),
CFN_BUILT_IN_HSAIL_LERP = int (BUILT_IN_HSAIL_LERP),
CFN_BUILT_IN_HSAIL_PACKCVT = int (BUILT_IN_HSAIL_PACKCVT),
CFN_BUILT_IN_HSAIL_UNPACKCVT = int (BUILT_IN_HSAIL_UNPACKCVT),
CFN_BUILT_IN_HSAIL_SAD_U16X2 = int (BUILT_IN_HSAIL_SAD_U16X2),
CFN_BUILT_IN_HSAIL_SAD_U32 = int (BUILT_IN_HSAIL_SAD_U32),
CFN_BUILT_IN_HSAIL_SAD_U8X4 = int (BUILT_IN_HSAIL_SAD_U8X4),
CFN_BUILT_IN_HSAIL_SADHI_U8X4 = int (BUILT_IN_HSAIL_SADHI_U8X4),
CFN_BUILT_IN_HSAIL_CLOCK = int (BUILT_IN_HSAIL_CLOCK),
CFN_BUILT_IN_HSAIL_CUID = int (BUILT_IN_HSAIL_CUID),
CFN_BUILT_IN_HSAIL_MAXCUID = int (BUILT_IN_HSAIL_MAXCUID),
CFN_BUILT_IN_HSAIL_DEBUGTRAP = int (BUILT_IN_HSAIL_DEBUGTRAP),
CFN_BUILT_IN_HSAIL_GROUPBASEPTR = int (BUILT_IN_HSAIL_GROUPBASEPTR),
CFN_BUILT_IN_HSAIL_KERNARGBASEPTR_U64 = int (BUILT_IN_HSAIL_KERNARGBASEPTR_U64),
CFN_BUILT_IN_HSAIL_KERNARGBASEPTR_U32 = int (BUILT_IN_HSAIL_KERNARGBASEPTR_U32),
CFN_BUILT_IN_HSAIL_ALLOCA = int (BUILT_IN_HSAIL_ALLOCA),
CFN_BUILT_IN_HSAIL_LDQUEUEWRITEINDEX = int (BUILT_IN_HSAIL_LDQUEUEWRITEINDEX),
CFN_BUILT_IN_HSAIL_LDQUEUEREADINDEX = int (BUILT_IN_HSAIL_LDQUEUEREADINDEX),
CFN_BUILT_IN_HSAIL_STQUEUEWRITEINDEX = int (BUILT_IN_HSAIL_STQUEUEWRITEINDEX),
CFN_BUILT_IN_HSAIL_STQUEUEREADINDEX = int (BUILT_IN_HSAIL_STQUEUEREADINDEX),
CFN_BUILT_IN_HSAIL_ADDQUEUEWRITEINDEX = int (BUILT_IN_HSAIL_ADDQUEUEWRITEINDEX),
CFN_BUILT_IN_HSAIL_CASQUEUEWRITEINDEX = int (BUILT_IN_HSAIL_CASQUEUEWRITEINDEX),
CFN_BUILT_IN_HSAIL_SEGMENTP_GLOBAL = int (BUILT_IN_HSAIL_SEGMENTP_GLOBAL),
CFN_BUILT_IN_HSAIL_SEGMENTP_GROUP = int (BUILT_IN_HSAIL_SEGMENTP_GROUP),
CFN_BUILT_IN_HSAIL_SEGMENTP_PRIVATE = int (BUILT_IN_HSAIL_SEGMENTP_PRIVATE),
# 392 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def"
CFN_BUILT_IN_HSAIL_ATOMIC_MIN_S32 = int (BUILT_IN_HSAIL_ATOMIC_MIN_S32),
CFN_BUILT_IN_HSAIL_ATOMIC_MIN_S64 = int (BUILT_IN_HSAIL_ATOMIC_MIN_S64),
CFN_BUILT_IN_HSAIL_ATOMIC_MIN_U32 = int (BUILT_IN_HSAIL_ATOMIC_MIN_U32),
CFN_BUILT_IN_HSAIL_ATOMIC_MIN_U64 = int (BUILT_IN_HSAIL_ATOMIC_MIN_U64),
CFN_BUILT_IN_HSAIL_ATOMIC_MAX_S32 = int (BUILT_IN_HSAIL_ATOMIC_MAX_S32),
CFN_BUILT_IN_HSAIL_ATOMIC_MAX_S64 = int (BUILT_IN_HSAIL_ATOMIC_MAX_S64),
CFN_BUILT_IN_HSAIL_ATOMIC_MAX_U32 = int (BUILT_IN_HSAIL_ATOMIC_MAX_U32),
CFN_BUILT_IN_HSAIL_ATOMIC_MAX_U64 = int (BUILT_IN_HSAIL_ATOMIC_MAX_U64),
CFN_BUILT_IN_HSAIL_ATOMIC_WRAPDEC_U32 = int (BUILT_IN_HSAIL_ATOMIC_WRAPDEC_U32),
CFN_BUILT_IN_HSAIL_ATOMIC_WRAPDEC_U64 = int (BUILT_IN_HSAIL_ATOMIC_WRAPDEC_U64),
CFN_BUILT_IN_HSAIL_ATOMIC_WRAPINC_U32 = int (BUILT_IN_HSAIL_ATOMIC_WRAPINC_U32),
CFN_BUILT_IN_HSAIL_ATOMIC_WRAPINC_U64 = int (BUILT_IN_HSAIL_ATOMIC_WRAPINC_U64),
# 449 "/home/giulianob/gcc_git_gnu/gcc/gcc/brig-builtins.def"
CFN_BUILT_IN_HSAIL_SAT_ADD_U64 = int (BUILT_IN_HSAIL_SAT_ADD_U64),
CFN_BUILT_IN_HSAIL_SAT_ADD_S64 = int (BUILT_IN_HSAIL_SAT_ADD_S64),
CFN_BUILT_IN_HSAIL_SAT_ADD_U32 = int (BUILT_IN_HSAIL_SAT_ADD_U32),
CFN_BUILT_IN_HSAIL_SAT_ADD_S32 = int (BUILT_IN_HSAIL_SAT_ADD_S32),
CFN_BUILT_IN_HSAIL_SAT_ADD_U16 = int (BUILT_IN_HSAIL_SAT_ADD_U16),
CFN_BUILT_IN_HSAIL_SAT_ADD_S16 = int (BUILT_IN_HSAIL_SAT_ADD_S16),
CFN_BUILT_IN_HSAIL_SAT_ADD_U8 = int (BUILT_IN_HSAIL_SAT_ADD_U8),
CFN_BUILT_IN_HSAIL_SAT_ADD_S8 = int (BUILT_IN_HSAIL_SAT_ADD_S8),
CFN_BUILT_IN_HSAIL_SAT_SUB_U64 = int (BUILT_IN_HSAIL_SAT_SUB_U64),
CFN_BUILT_IN_HSAIL_SAT_SUB_S64 = int (BUILT_IN_HSAIL_SAT_SUB_S64),
CFN_BUILT_IN_HSAIL_SAT_SUB_U32 = int (BUILT_IN_HSAIL_SAT_SUB_U32),
CFN_BUILT_IN_HSAIL_SAT_SUB_S32 = int (BUILT_IN_HSAIL_SAT_SUB_S32),
CFN_BUILT_IN_HSAIL_SAT_SUB_U16 = int (BUILT_IN_HSAIL_SAT_SUB_U16),
CFN_BUILT_IN_HSAIL_SAT_SUB_S16 = int (BUILT_IN_HSAIL_SAT_SUB_S16),
CFN_BUILT_IN_HSAIL_SAT_SUB_U8 = int (BUILT_IN_HSAIL_SAT_SUB_U8),
CFN_BUILT_IN_HSAIL_SAT_SUB_S8 = int (BUILT_IN_HSAIL_SAT_SUB_S8),
CFN_BUILT_IN_HSAIL_SAT_MUL_U64 = int (BUILT_IN_HSAIL_SAT_MUL_U64),
CFN_BUILT_IN_HSAIL_SAT_MUL_S64 = int (BUILT_IN_HSAIL_SAT_MUL_S64),
CFN_BUILT_IN_HSAIL_SAT_MUL_U32 = int (BUILT_IN_HSAIL_SAT_MUL_U32),
CFN_BUILT_IN_HSAIL_SAT_MUL_S32 = int (BUILT_IN_HSAIL_SAT_MUL_S32),
CFN_BUILT_IN_HSAIL_SAT_MUL_U16 = int (BUILT_IN_HSAIL_SAT_MUL_U16),
CFN_BUILT_IN_HSAIL_SAT_MUL_S16 = int (BUILT_IN_HSAIL_SAT_MUL_S16),
CFN_BUILT_IN_HSAIL_SAT_MUL_U8 = int (BUILT_IN_HSAIL_SAT_MUL_U8),
CFN_BUILT_IN_HSAIL_SAT_MUL_S8 = int (BUILT_IN_HSAIL_SAT_MUL_S8),
CFN_BUILT_IN_HSAIL_FTZ_F32_F16 = int (BUILT_IN_HSAIL_FTZ_F32_F16),
CFN_BUILT_IN_HSAIL_FTZ_F32 = int (BUILT_IN_HSAIL_FTZ_F32),
CFN_BUILT_IN_HSAIL_FTZ_F64 = int (BUILT_IN_HSAIL_FTZ_F64),
CFN_BUILT_IN_HSAIL_PUSH_FRAME = int (BUILT_IN_HSAIL_PUSH_FRAME),
CFN_BUILT_IN_HSAIL_POP_FRAME = int (BUILT_IN_HSAIL_POP_FRAME),
CFN_BUILT_IN_HSAIL_SETWORKITEMID = int (BUILT_IN_HSAIL_SETWORKITEMID),
CFN_BUILT_IN_HSAIL_LAUNCH_WG_FUNC = int (BUILT_IN_HSAIL_LAUNCH_WG_FUNC),
CFN_BUILT_IN_HSAIL_LAUNCH_KERNEL = int (BUILT_IN_HSAIL_LAUNCH_KERNEL),
CFN_BUILT_IN_HSAIL_F32_TO_F16 = int (BUILT_IN_HSAIL_F32_TO_F16),
CFN_BUILT_IN_HSAIL_F16_TO_F32 = int (BUILT_IN_HSAIL_F16_TO_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U8_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U8_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S8_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S8_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U16_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U16_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S16_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S16_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U32_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U32_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S32_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S32_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U64_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U64_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S64_F32 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S64_F32),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U8_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U8_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S8_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S8_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U16_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U16_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S16_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S16_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U32_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U32_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S32_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S32_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_U64_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_U64_F64),
CFN_BUILT_IN_HSAIL_CVT_ZEROI_SAT_S64_F64 = int (BUILT_IN_HSAIL_CVT_ZEROI_SAT_S64_F64),
# 1104 "/home/giulianob/gcc_git_gnu/gcc/gcc/builtins.def" 2
# 202 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/internal-fn.def" 1
# 123 "/home/giulianob/gcc_git_gnu/gcc/gcc/internal-fn.def"
CFN_MASK_LOAD = int (END_BUILTINS) + int (IFN_MASK_LOAD),
CFN_LOAD_LANES = int (END_BUILTINS) + int (IFN_LOAD_LANES),
CFN_MASK_LOAD_LANES = int (END_BUILTINS) + int (IFN_MASK_LOAD_LANES),
CFN_GATHER_LOAD = int (END_BUILTINS) + int (IFN_GATHER_LOAD),
CFN_MASK_GATHER_LOAD = int (END_BUILTINS) + int (IFN_MASK_GATHER_LOAD),
CFN_LEN_LOAD = int (END_BUILTINS) + int (IFN_LEN_LOAD),
CFN_SCATTER_STORE = int (END_BUILTINS) + int (IFN_SCATTER_STORE),
CFN_MASK_SCATTER_STORE = int (END_BUILTINS) + int (IFN_MASK_SCATTER_STORE),
CFN_MASK_STORE = int (END_BUILTINS) + int (IFN_MASK_STORE),
CFN_STORE_LANES = int (END_BUILTINS) + int (IFN_STORE_LANES),
CFN_MASK_STORE_LANES = int (END_BUILTINS) + int (IFN_MASK_STORE_LANES),
CFN_VCOND = int (END_BUILTINS) + int (IFN_VCOND),
CFN_VCONDU = int (END_BUILTINS) + int (IFN_VCONDU),
CFN_VCONDEQ = int (END_BUILTINS) + int (IFN_VCONDEQ),
CFN_VCOND_MASK = int (END_BUILTINS) + int (IFN_VCOND_MASK),
CFN_LEN_STORE = int (END_BUILTINS) + int (IFN_LEN_STORE),
CFN_WHILE_ULT = int (END_BUILTINS) + int (IFN_WHILE_ULT),
CFN_CHECK_RAW_PTRS = int (END_BUILTINS) + int (IFN_CHECK_RAW_PTRS),
CFN_CHECK_WAR_PTRS = int (END_BUILTINS) + int (IFN_CHECK_WAR_PTRS),
CFN_VEC_SHL_INSERT = int (END_BUILTINS) + int (IFN_VEC_SHL_INSERT),
CFN_DIV_POW2 = int (END_BUILTINS) + int (IFN_DIV_POW2),
CFN_FMS = int (END_BUILTINS) + int (IFN_FMS),
CFN_FNMA = int (END_BUILTINS) + int (IFN_FNMA),
CFN_FNMS = int (END_BUILTINS) + int (IFN_FNMS),
CFN_AVG_FLOOR = int (END_BUILTINS) + int (IFN_AVG_FLOOR),
CFN_AVG_CEIL = int (END_BUILTINS) + int (IFN_AVG_CEIL),
CFN_MULHS = int (END_BUILTINS) + int (IFN_MULHS),
CFN_MULHRS = int (END_BUILTINS) + int (IFN_MULHRS),
CFN_COND_ADD = int (END_BUILTINS) + int (IFN_COND_ADD),
CFN_COND_SUB = int (END_BUILTINS) + int (IFN_COND_SUB),
CFN_COND_MUL = int (END_BUILTINS) + int (IFN_COND_MUL),
CFN_COND_DIV = int (END_BUILTINS) + int (IFN_COND_DIV),
CFN_COND_MOD = int (END_BUILTINS) + int (IFN_COND_MOD),
CFN_COND_RDIV = int (END_BUILTINS) + int (IFN_COND_RDIV),
CFN_COND_MIN = int (END_BUILTINS) + int (IFN_COND_MIN),
CFN_COND_MAX = int (END_BUILTINS) + int (IFN_COND_MAX),
CFN_COND_AND = int (END_BUILTINS) + int (IFN_COND_AND),
CFN_COND_IOR = int (END_BUILTINS) + int (IFN_COND_IOR),
CFN_COND_XOR = int (END_BUILTINS) + int (IFN_COND_XOR),
CFN_COND_SHL = int (END_BUILTINS) + int (IFN_COND_SHL),
CFN_COND_SHR = int (END_BUILTINS) + int (IFN_COND_SHR),
CFN_COND_FMA = int (END_BUILTINS) + int (IFN_COND_FMA),
CFN_COND_FMS = int (END_BUILTINS) + int (IFN_COND_FMS),
CFN_COND_FNMA = int (END_BUILTINS) + int (IFN_COND_FNMA),
CFN_COND_FNMS = int (END_BUILTINS) + int (IFN_COND_FNMS),
CFN_RSQRT = int (END_BUILTINS) + int (IFN_RSQRT),
CFN_REDUC_PLUS = int (END_BUILTINS) + int (IFN_REDUC_PLUS),
CFN_REDUC_MAX = int (END_BUILTINS) + int (IFN_REDUC_MAX),
CFN_REDUC_MIN = int (END_BUILTINS) + int (IFN_REDUC_MIN),
CFN_REDUC_AND = int (END_BUILTINS) + int (IFN_REDUC_AND),
CFN_REDUC_IOR = int (END_BUILTINS) + int (IFN_REDUC_IOR),
CFN_REDUC_XOR = int (END_BUILTINS) + int (IFN_REDUC_XOR),
CFN_EXTRACT_LAST = int (END_BUILTINS) + int (IFN_EXTRACT_LAST),
CFN_FOLD_EXTRACT_LAST = int (END_BUILTINS) + int (IFN_FOLD_EXTRACT_LAST),
CFN_FOLD_LEFT_PLUS = int (END_BUILTINS) + int (IFN_FOLD_LEFT_PLUS),
CFN_MASK_FOLD_LEFT_PLUS = int (END_BUILTINS) + int (IFN_MASK_FOLD_LEFT_PLUS),
CFN_ACOS = int (END_BUILTINS) + int (IFN_ACOS),
CFN_ACOSH = int (END_BUILTINS) + int (IFN_ACOSH),
CFN_ASIN = int (END_BUILTINS) + int (IFN_ASIN),
CFN_ASINH = int (END_BUILTINS) + int (IFN_ASINH),
CFN_ATAN = int (END_BUILTINS) + int (IFN_ATAN),
CFN_ATANH = int (END_BUILTINS) + int (IFN_ATANH),
CFN_COS = int (END_BUILTINS) + int (IFN_COS),
CFN_COSH = int (END_BUILTINS) + int (IFN_COSH),
CFN_EXP = int (END_BUILTINS) + int (IFN_EXP),
CFN_EXP10 = int (END_BUILTINS) + int (IFN_EXP10),
CFN_EXP2 = int (END_BUILTINS) + int (IFN_EXP2),
CFN_EXPM1 = int (END_BUILTINS) + int (IFN_EXPM1),
CFN_LOG = int (END_BUILTINS) + int (IFN_LOG),
CFN_LOG10 = int (END_BUILTINS) + int (IFN_LOG10),
CFN_LOG1P = int (END_BUILTINS) + int (IFN_LOG1P),
CFN_LOG2 = int (END_BUILTINS) + int (IFN_LOG2),
CFN_LOGB = int (END_BUILTINS) + int (IFN_LOGB),
CFN_SIGNBIT = int (END_BUILTINS) + int (IFN_SIGNBIT),
CFN_SIGNIFICAND = int (END_BUILTINS) + int (IFN_SIGNIFICAND),
CFN_SIN = int (END_BUILTINS) + int (IFN_SIN),
CFN_SINH = int (END_BUILTINS) + int (IFN_SINH),
CFN_SQRT = int (END_BUILTINS) + int (IFN_SQRT),
CFN_TAN = int (END_BUILTINS) + int (IFN_TAN),
CFN_TANH = int (END_BUILTINS) + int (IFN_TANH),
CFN_CEIL = int (END_BUILTINS) + int (IFN_CEIL),
CFN_FLOOR = int (END_BUILTINS) + int (IFN_FLOOR),
CFN_NEARBYINT = int (END_BUILTINS) + int (IFN_NEARBYINT),
CFN_RINT = int (END_BUILTINS) + int (IFN_RINT),
CFN_ROUND = int (END_BUILTINS) + int (IFN_ROUND),
CFN_ROUNDEVEN = int (END_BUILTINS) + int (IFN_ROUNDEVEN),
CFN_TRUNC = int (END_BUILTINS) + int (IFN_TRUNC),
CFN_ATAN2 = int (END_BUILTINS) + int (IFN_ATAN2),
CFN_COPYSIGN = int (END_BUILTINS) + int (IFN_COPYSIGN),
CFN_FMOD = int (END_BUILTINS) + int (IFN_FMOD),
CFN_HYPOT = int (END_BUILTINS) + int (IFN_HYPOT),
CFN_POW = int (END_BUILTINS) + int (IFN_POW),
CFN_REMAINDER = int (END_BUILTINS) + int (IFN_REMAINDER),
CFN_SCALB = int (END_BUILTINS) + int (IFN_SCALB),
CFN_FMIN = int (END_BUILTINS) + int (IFN_FMIN),
CFN_FMAX = int (END_BUILTINS) + int (IFN_FMAX),
CFN_XORSIGN = int (END_BUILTINS) + int (IFN_XORSIGN),
CFN_LDEXP = int (END_BUILTINS) + int (IFN_LDEXP),
CFN_FMA = int (END_BUILTINS) + int (IFN_FMA),
CFN_CLRSB = int (END_BUILTINS) + int (IFN_CLRSB),
CFN_CLZ = int (END_BUILTINS) + int (IFN_CLZ),
CFN_CTZ = int (END_BUILTINS) + int (IFN_CTZ),
CFN_FFS = int (END_BUILTINS) + int (IFN_FFS),
CFN_PARITY = int (END_BUILTINS) + int (IFN_PARITY),
CFN_POPCOUNT = int (END_BUILTINS) + int (IFN_POPCOUNT),
CFN_GOMP_USE_SIMT = int (END_BUILTINS) + int (IFN_GOMP_USE_SIMT),
CFN_GOMP_SIMT_ENTER = int (END_BUILTINS) + int (IFN_GOMP_SIMT_ENTER),
CFN_GOMP_SIMT_ENTER_ALLOC = int (END_BUILTINS) + int (IFN_GOMP_SIMT_ENTER_ALLOC),
CFN_GOMP_SIMT_EXIT = int (END_BUILTINS) + int (IFN_GOMP_SIMT_EXIT),
CFN_GOMP_SIMT_LANE = int (END_BUILTINS) + int (IFN_GOMP_SIMT_LANE),
CFN_GOMP_SIMT_VF = int (END_BUILTINS) + int (IFN_GOMP_SIMT_VF),
CFN_GOMP_SIMT_LAST_LANE = int (END_BUILTINS) + int (IFN_GOMP_SIMT_LAST_LANE),
CFN_GOMP_SIMT_ORDERED_PRED = int (END_BUILTINS) + int (IFN_GOMP_SIMT_ORDERED_PRED),
CFN_GOMP_SIMT_VOTE_ANY = int (END_BUILTINS) + int (IFN_GOMP_SIMT_VOTE_ANY),
CFN_GOMP_SIMT_XCHG_BFLY = int (END_BUILTINS) + int (IFN_GOMP_SIMT_XCHG_BFLY),
CFN_GOMP_SIMT_XCHG_IDX = int (END_BUILTINS) + int (IFN_GOMP_SIMT_XCHG_IDX),
CFN_GOMP_SIMD_LANE = int (END_BUILTINS) + int (IFN_GOMP_SIMD_LANE),
CFN_GOMP_SIMD_VF = int (END_BUILTINS) + int (IFN_GOMP_SIMD_VF),
CFN_GOMP_SIMD_LAST_LANE = int (END_BUILTINS) + int (IFN_GOMP_SIMD_LAST_LANE),
CFN_GOMP_SIMD_ORDERED_START = int (END_BUILTINS) + int (IFN_GOMP_SIMD_ORDERED_START),
CFN_GOMP_SIMD_ORDERED_END = int (END_BUILTINS) + int (IFN_GOMP_SIMD_ORDERED_END),
CFN_LOOP_VECTORIZED = int (END_BUILTINS) + int (IFN_LOOP_VECTORIZED),
CFN_LOOP_DIST_ALIAS = int (END_BUILTINS) + int (IFN_LOOP_DIST_ALIAS),
CFN_ANNOTATE = int (END_BUILTINS) + int (IFN_ANNOTATE),
CFN_UBSAN_NULL = int (END_BUILTINS) + int (IFN_UBSAN_NULL),
CFN_UBSAN_BOUNDS = int (END_BUILTINS) + int (IFN_UBSAN_BOUNDS),
CFN_UBSAN_VPTR = int (END_BUILTINS) + int (IFN_UBSAN_VPTR),
CFN_UBSAN_CHECK_ADD = int (END_BUILTINS) + int (IFN_UBSAN_CHECK_ADD),
CFN_UBSAN_CHECK_SUB = int (END_BUILTINS) + int (IFN_UBSAN_CHECK_SUB),
CFN_UBSAN_CHECK_MUL = int (END_BUILTINS) + int (IFN_UBSAN_CHECK_MUL),
CFN_UBSAN_PTR = int (END_BUILTINS) + int (IFN_UBSAN_PTR),
CFN_UBSAN_OBJECT_SIZE = int (END_BUILTINS) + int (IFN_UBSAN_OBJECT_SIZE),
CFN_ABNORMAL_DISPATCHER = int (END_BUILTINS) + int (IFN_ABNORMAL_DISPATCHER),
CFN_BUILTIN_EXPECT = int (END_BUILTINS) + int (IFN_BUILTIN_EXPECT),
CFN_ASAN_CHECK = int (END_BUILTINS) + int (IFN_ASAN_CHECK),
CFN_ASAN_MARK = int (END_BUILTINS) + int (IFN_ASAN_MARK),
CFN_ASAN_POISON = int (END_BUILTINS) + int (IFN_ASAN_POISON),
CFN_ASAN_POISON_USE = int (END_BUILTINS) + int (IFN_ASAN_POISON_USE),
CFN_ADD_OVERFLOW = int (END_BUILTINS) + int (IFN_ADD_OVERFLOW),
CFN_SUB_OVERFLOW = int (END_BUILTINS) + int (IFN_SUB_OVERFLOW),
CFN_MUL_OVERFLOW = int (END_BUILTINS) + int (IFN_MUL_OVERFLOW),
CFN_TSAN_FUNC_EXIT = int (END_BUILTINS) + int (IFN_TSAN_FUNC_EXIT),
CFN_VA_ARG = int (END_BUILTINS) + int (IFN_VA_ARG),
CFN_VEC_CONVERT = int (END_BUILTINS) + int (IFN_VEC_CONVERT),
CFN_UNIQUE = int (END_BUILTINS) + int (IFN_UNIQUE),
CFN_PHI = int (END_BUILTINS) + int (IFN_PHI),
CFN_GOACC_DIM_SIZE = int (END_BUILTINS) + int (IFN_GOACC_DIM_SIZE),
CFN_GOACC_DIM_POS = int (END_BUILTINS) + int (IFN_GOACC_DIM_POS),
CFN_GOACC_LOOP = int (END_BUILTINS) + int (IFN_GOACC_LOOP),
CFN_GOACC_REDUCTION = int (END_BUILTINS) + int (IFN_GOACC_REDUCTION),
CFN_GOACC_TILE = int (END_BUILTINS) + int (IFN_GOACC_TILE),
CFN_SET_EDOM = int (END_BUILTINS) + int (IFN_SET_EDOM),
CFN_ATOMIC_BIT_TEST_AND_SET = int (END_BUILTINS) + int (IFN_ATOMIC_BIT_TEST_AND_SET),
CFN_ATOMIC_BIT_TEST_AND_COMPLEMENT = int (END_BUILTINS) + int (IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT),
CFN_ATOMIC_BIT_TEST_AND_RESET = int (END_BUILTINS) + int (IFN_ATOMIC_BIT_TEST_AND_RESET),
CFN_ATOMIC_COMPARE_EXCHANGE = int (END_BUILTINS) + int (IFN_ATOMIC_COMPARE_EXCHANGE),
CFN_FALLTHROUGH = int (END_BUILTINS) + int (IFN_FALLTHROUGH),
CFN_LAUNDER = int (END_BUILTINS) + int (IFN_LAUNDER),
CFN_DIVMOD = int (END_BUILTINS) + int (IFN_DIVMOD),
CFN_CO_ACTOR = int (END_BUILTINS) + int (IFN_CO_ACTOR),
CFN_CO_YIELD = int (END_BUILTINS) + int (IFN_CO_YIELD),
CFN_CO_SUSPN = int (END_BUILTINS) + int (IFN_CO_SUSPN),
CFN_CO_FRAME = int (END_BUILTINS) + int (IFN_CO_FRAME),
CFN_NOP = int (END_BUILTINS) + int (IFN_NOP),
# 207 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
CFN_LAST
};
enum tree_code_class {
tcc_exceptional,
tcc_constant,
tcc_type,
tcc_declaration,
tcc_reference,
tcc_comparison,
tcc_unary,
tcc_binary,
tcc_statement,
tcc_vl_exp,
tcc_expression
};
enum omp_clause_code {
OMP_CLAUSE_ERROR = 0,
OMP_CLAUSE_PRIVATE,
OMP_CLAUSE_SHARED,
OMP_CLAUSE_FIRSTPRIVATE,
OMP_CLAUSE_LASTPRIVATE,
# 259 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
OMP_CLAUSE_REDUCTION,
OMP_CLAUSE_TASK_REDUCTION,
OMP_CLAUSE_IN_REDUCTION,
OMP_CLAUSE_COPYIN,
OMP_CLAUSE_COPYPRIVATE,
OMP_CLAUSE_LINEAR,
OMP_CLAUSE_ALIGNED,
OMP_CLAUSE_DEPEND,
OMP_CLAUSE_NONTEMPORAL,
OMP_CLAUSE_UNIFORM,
OMP_CLAUSE_TO_DECLARE,
OMP_CLAUSE_LINK,
OMP_CLAUSE_FROM,
OMP_CLAUSE_TO,
OMP_CLAUSE_MAP,
OMP_CLAUSE_USE_DEVICE_PTR,
OMP_CLAUSE_USE_DEVICE_ADDR,
OMP_CLAUSE_IS_DEVICE_PTR,
OMP_CLAUSE_INCLUSIVE,
OMP_CLAUSE_EXCLUSIVE,
OMP_CLAUSE__CACHE_,
OMP_CLAUSE_GANG,
OMP_CLAUSE_ASYNC,
OMP_CLAUSE_WAIT,
OMP_CLAUSE_AUTO,
OMP_CLAUSE_SEQ,
OMP_CLAUSE__LOOPTEMP_,
OMP_CLAUSE__REDUCTEMP_,
OMP_CLAUSE__CONDTEMP_,
OMP_CLAUSE__SCANTEMP_,
OMP_CLAUSE_IF,
OMP_CLAUSE_NUM_THREADS,
OMP_CLAUSE_SCHEDULE,
OMP_CLAUSE_NOWAIT,
OMP_CLAUSE_ORDERED,
OMP_CLAUSE_DEFAULT,
OMP_CLAUSE_COLLAPSE,
OMP_CLAUSE_UNTIED,
OMP_CLAUSE_FINAL,
OMP_CLAUSE_MERGEABLE,
OMP_CLAUSE_DEVICE,
OMP_CLAUSE_DIST_SCHEDULE,
OMP_CLAUSE_INBRANCH,
OMP_CLAUSE_NOTINBRANCH,
OMP_CLAUSE_NUM_TEAMS,
OMP_CLAUSE_THREAD_LIMIT,
OMP_CLAUSE_PROC_BIND,
OMP_CLAUSE_SAFELEN,
OMP_CLAUSE_SIMDLEN,
OMP_CLAUSE_DEVICE_TYPE,
OMP_CLAUSE_FOR,
OMP_CLAUSE_PARALLEL,
OMP_CLAUSE_SECTIONS,
OMP_CLAUSE_TASKGROUP,
OMP_CLAUSE_PRIORITY,
OMP_CLAUSE_GRAINSIZE,
OMP_CLAUSE_NUM_TASKS,
OMP_CLAUSE_NOGROUP,
OMP_CLAUSE_THREADS,
OMP_CLAUSE_SIMD,
OMP_CLAUSE_HINT,
OMP_CLAUSE_DEFAULTMAP,
OMP_CLAUSE_ORDER,
OMP_CLAUSE_BIND,
OMP_CLAUSE__SIMDUID_,
OMP_CLAUSE__SIMT_,
OMP_CLAUSE_INDEPENDENT,
OMP_CLAUSE_WORKER,
OMP_CLAUSE_VECTOR,
OMP_CLAUSE_NUM_GANGS,
OMP_CLAUSE_NUM_WORKERS,
OMP_CLAUSE_VECTOR_LENGTH,
OMP_CLAUSE_TILE,
OMP_CLAUSE_IF_PRESENT,
OMP_CLAUSE_FINALIZE
};
enum tree_node_structure_enum {
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/treestruct.def" 1
# 33 "/home/giulianob/gcc_git_gnu/gcc/gcc/treestruct.def"
TS_BASE,
TS_TYPED,
TS_COMMON,
TS_INT_CST,
TS_POLY_INT_CST,
TS_REAL_CST,
TS_FIXED_CST,
TS_VECTOR,
TS_STRING,
TS_COMPLEX,
TS_IDENTIFIER,
TS_DECL_MINIMAL,
TS_DECL_COMMON,
TS_DECL_WRTL,
TS_DECL_NON_COMMON,
TS_DECL_WITH_VIS,
TS_FIELD_DECL,
TS_VAR_DECL,
TS_PARM_DECL,
TS_LABEL_DECL,
TS_RESULT_DECL,
TS_CONST_DECL,
TS_TYPE_DECL,
TS_FUNCTION_DECL,
TS_TRANSLATION_UNIT_DECL,
TS_TYPE_COMMON,
TS_TYPE_WITH_LANG_SPECIFIC,
TS_TYPE_NON_COMMON,
TS_LIST,
TS_VEC,
TS_EXP,
TS_SSA_NAME,
TS_BLOCK,
TS_BINFO,
TS_STATEMENT_LIST,
TS_CONSTRUCTOR,
TS_OMP_CLAUSE,
TS_OPTIMIZATION,
TS_TARGET_OPTION,
# 502 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h" 2
LAST_TS_ENUM
};
enum omp_clause_schedule_kind {
OMP_CLAUSE_SCHEDULE_STATIC,
OMP_CLAUSE_SCHEDULE_DYNAMIC,
OMP_CLAUSE_SCHEDULE_GUIDED,
OMP_CLAUSE_SCHEDULE_AUTO,
OMP_CLAUSE_SCHEDULE_RUNTIME,
OMP_CLAUSE_SCHEDULE_MASK = (1 << 3) - 1,
OMP_CLAUSE_SCHEDULE_MONOTONIC = (1 << 3),
OMP_CLAUSE_SCHEDULE_NONMONOTONIC = (1 << 4),
OMP_CLAUSE_SCHEDULE_LAST = 2 * OMP_CLAUSE_SCHEDULE_NONMONOTONIC - 1
};
enum omp_clause_default_kind {
OMP_CLAUSE_DEFAULT_UNSPECIFIED,
OMP_CLAUSE_DEFAULT_SHARED,
OMP_CLAUSE_DEFAULT_NONE,
OMP_CLAUSE_DEFAULT_PRIVATE,
OMP_CLAUSE_DEFAULT_FIRSTPRIVATE,
OMP_CLAUSE_DEFAULT_PRESENT,
OMP_CLAUSE_DEFAULT_LAST
};
enum omp_clause_defaultmap_kind {
OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED,
OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR,
OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE,
OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE,
OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER,
OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK = 7,
OMP_CLAUSE_DEFAULTMAP_ALLOC = 1 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_TO = 2 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_FROM = 3 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_TOFROM = 4 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
= 5 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_NONE = 6 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_DEFAULT
= 7 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
OMP_CLAUSE_DEFAULTMAP_MASK = 7 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1)
};
enum omp_clause_bind_kind {
OMP_CLAUSE_BIND_TEAMS,
OMP_CLAUSE_BIND_PARALLEL,
OMP_CLAUSE_BIND_THREAD
};
enum omp_memory_order {
OMP_MEMORY_ORDER_UNSPECIFIED,
OMP_MEMORY_ORDER_RELAXED,
OMP_MEMORY_ORDER_ACQUIRE,
OMP_MEMORY_ORDER_RELEASE,
OMP_MEMORY_ORDER_ACQ_REL,
OMP_MEMORY_ORDER_SEQ_CST
};
enum cv_qualifier {
TYPE_UNQUALIFIED = 0x0,
TYPE_QUAL_CONST = 0x1,
TYPE_QUAL_VOLATILE = 0x2,
TYPE_QUAL_RESTRICT = 0x4,
TYPE_QUAL_ATOMIC = 0x8
};
enum tree_index {
TI_ERROR_MARK,
TI_INTQI_TYPE,
TI_INTHI_TYPE,
TI_INTSI_TYPE,
TI_INTDI_TYPE,
TI_INTTI_TYPE,
TI_UINTQI_TYPE,
TI_UINTHI_TYPE,
TI_UINTSI_TYPE,
TI_UINTDI_TYPE,
TI_UINTTI_TYPE,
TI_ATOMICQI_TYPE,
TI_ATOMICHI_TYPE,
TI_ATOMICSI_TYPE,
TI_ATOMICDI_TYPE,
TI_ATOMICTI_TYPE,
TI_UINT16_TYPE,
TI_UINT32_TYPE,
TI_UINT64_TYPE,
TI_UINT128_TYPE,
TI_VOID,
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
TI_INTEGER_THREE,
TI_INTEGER_MINUS_ONE,
TI_NULL_POINTER,
TI_SIZE_ZERO,
TI_SIZE_ONE,
TI_BITSIZE_ZERO,
TI_BITSIZE_ONE,
TI_BITSIZE_UNIT,
TI_PUBLIC,
TI_PROTECTED,
TI_PRIVATE,
TI_BOOLEAN_FALSE,
TI_BOOLEAN_TRUE,
TI_FLOAT_TYPE,
TI_DOUBLE_TYPE,
TI_LONG_DOUBLE_TYPE,
TI_FLOAT16_TYPE,
TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE,
TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE,
TI_FLOAT32_TYPE,
TI_FLOAT64_TYPE,
TI_FLOAT128_TYPE,
TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE,
TI_FLOAT32X_TYPE,
TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE,
TI_FLOAT64X_TYPE,
TI_FLOAT128X_TYPE,
TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE,
TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE,
# 655 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
TI_COMPLEX_INTEGER_TYPE,
TI_COMPLEX_FLOAT_TYPE,
TI_COMPLEX_DOUBLE_TYPE,
TI_COMPLEX_LONG_DOUBLE_TYPE,
TI_COMPLEX_FLOAT16_TYPE,
TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
TI_COMPLEX_FLOAT32_TYPE,
TI_COMPLEX_FLOAT64_TYPE,
TI_COMPLEX_FLOAT128_TYPE,
TI_COMPLEX_FLOAT32X_TYPE,
TI_COMPLEX_FLOAT64X_TYPE,
TI_COMPLEX_FLOAT128X_TYPE,
TI_FLOAT_PTR_TYPE,
TI_DOUBLE_PTR_TYPE,
TI_LONG_DOUBLE_PTR_TYPE,
TI_INTEGER_PTR_TYPE,
TI_VOID_TYPE,
TI_PTR_TYPE,
TI_CONST_PTR_TYPE,
TI_SIZE_TYPE,
TI_PID_TYPE,
TI_PTRDIFF_TYPE,
TI_VA_LIST_TYPE,
TI_VA_LIST_GPR_COUNTER_FIELD,
TI_VA_LIST_FPR_COUNTER_FIELD,
TI_BOOLEAN_TYPE,
TI_FILEPTR_TYPE,
TI_CONST_TM_PTR_TYPE,
TI_FENV_T_PTR_TYPE,
TI_CONST_FENV_T_PTR_TYPE,
TI_FEXCEPT_T_PTR_TYPE,
TI_CONST_FEXCEPT_T_PTR_TYPE,
TI_POINTER_SIZED_TYPE,
TI_DFLOAT32_TYPE,
TI_DFLOAT64_TYPE,
TI_DFLOAT128_TYPE,
TI_VOID_LIST_NODE,
TI_MAIN_IDENTIFIER,
TI_SAT_SFRACT_TYPE,
TI_SAT_FRACT_TYPE,
TI_SAT_LFRACT_TYPE,
TI_SAT_LLFRACT_TYPE,
TI_SAT_USFRACT_TYPE,
TI_SAT_UFRACT_TYPE,
TI_SAT_ULFRACT_TYPE,
TI_SAT_ULLFRACT_TYPE,
TI_SFRACT_TYPE,
TI_FRACT_TYPE,
TI_LFRACT_TYPE,
TI_LLFRACT_TYPE,
TI_USFRACT_TYPE,
TI_UFRACT_TYPE,
TI_ULFRACT_TYPE,
TI_ULLFRACT_TYPE,
TI_SAT_SACCUM_TYPE,
TI_SAT_ACCUM_TYPE,
TI_SAT_LACCUM_TYPE,
TI_SAT_LLACCUM_TYPE,
TI_SAT_USACCUM_TYPE,
TI_SAT_UACCUM_TYPE,
TI_SAT_ULACCUM_TYPE,
TI_SAT_ULLACCUM_TYPE,
TI_SACCUM_TYPE,
TI_ACCUM_TYPE,
TI_LACCUM_TYPE,
TI_LLACCUM_TYPE,
TI_USACCUM_TYPE,
TI_UACCUM_TYPE,
TI_ULACCUM_TYPE,
TI_ULLACCUM_TYPE,
TI_QQ_TYPE,
TI_HQ_TYPE,
TI_SQ_TYPE,
TI_DQ_TYPE,
TI_TQ_TYPE,
TI_UQQ_TYPE,
TI_UHQ_TYPE,
TI_USQ_TYPE,
TI_UDQ_TYPE,
TI_UTQ_TYPE,
TI_SAT_QQ_TYPE,
TI_SAT_HQ_TYPE,
TI_SAT_SQ_TYPE,
TI_SAT_DQ_TYPE,
TI_SAT_TQ_TYPE,
TI_SAT_UQQ_TYPE,
TI_SAT_UHQ_TYPE,
TI_SAT_USQ_TYPE,
TI_SAT_UDQ_TYPE,
TI_SAT_UTQ_TYPE,
TI_HA_TYPE,
TI_SA_TYPE,
TI_DA_TYPE,
TI_TA_TYPE,
TI_UHA_TYPE,
TI_USA_TYPE,
TI_UDA_TYPE,
TI_UTA_TYPE,
TI_SAT_HA_TYPE,
TI_SAT_SA_TYPE,
TI_SAT_DA_TYPE,
TI_SAT_TA_TYPE,
TI_SAT_UHA_TYPE,
TI_SAT_USA_TYPE,
TI_SAT_UDA_TYPE,
TI_SAT_UTA_TYPE,
TI_OPTIMIZATION_DEFAULT,
TI_OPTIMIZATION_CURRENT,
TI_TARGET_OPTION_DEFAULT,
TI_TARGET_OPTION_CURRENT,
TI_CURRENT_TARGET_PRAGMA,
TI_CURRENT_OPTIMIZE_PRAGMA,
TI_CHREC_DONT_KNOW,
TI_CHREC_KNOWN,
TI_MAX
};
enum integer_type_kind {
itk_char,
itk_signed_char,
itk_unsigned_char,
itk_short,
itk_unsigned_short,
itk_int,
itk_unsigned_int,
itk_long,
itk_unsigned_long,
itk_long_long,
itk_unsigned_long_long,
itk_intN_0,
itk_unsigned_intN_0,
itk_intN_1,
itk_unsigned_intN_1,
itk_intN_2,
itk_unsigned_intN_2,
itk_intN_3,
itk_unsigned_intN_3,
itk_none
};
# 831 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
enum ptrmemfunc_vbit_where_t {
ptrmemfunc_vbit_in_pfn,
ptrmemfunc_vbit_in_delta
};
enum attribute_flags {
ATTR_FLAG_DECL_NEXT = 1,
ATTR_FLAG_FUNCTION_NEXT = 2,
ATTR_FLAG_ARRAY_NEXT = 4,
ATTR_FLAG_TYPE_IN_PLACE = 8,
ATTR_FLAG_BUILT_IN = 16,
ATTR_FLAG_CXX11 = 32
};
enum size_type_kind {
stk_sizetype,
stk_ssizetype,
stk_bitsizetype,
stk_sbitsizetype,
stk_type_kind_last
};
enum operand_equal_flag {
OEP_ONLY_CONST = 1,
OEP_PURE_SAME = 2,
OEP_MATCH_SIDE_EFFECTS = 4,
OEP_ADDRESS_OF = 8,
OEP_NO_HASH_CHECK = 16,
OEP_HASH_CHECK = 32,
OEP_LEXICOGRAPHIC = 64,
OEP_BITWISE = 128
};
enum tree_node_kind {
d_kind,
t_kind,
b_kind,
s_kind,
r_kind,
e_kind,
c_kind,
id_kind,
vec_kind,
binfo_kind,
ssa_name_kind,
constr_kind,
x_kind,
lang_decl,
lang_type,
omp_clause_kind,
all_kinds
};
enum annot_expr_kind {
annot_expr_ivdep_kind,
annot_expr_unroll_kind,
annot_expr_no_vector_kind,
annot_expr_vector_kind,
annot_expr_parallel_kind,
annot_expr_kind_last
};
struct alias_pair {
tree decl;
tree target;
};
typedef unsigned short priority_type;
typedef tree (*walk_tree_fn) (tree *, int *, void *);
typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
void *, hash_set<tree> *);
# 962 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
struct tree_base {
enum tree_code code : 16;
unsigned side_effects_flag : 1;
unsigned constant_flag : 1;
unsigned addressable_flag : 1;
unsigned volatile_flag : 1;
unsigned readonly_flag : 1;
unsigned asm_written_flag: 1;
unsigned nowarning_flag : 1;
unsigned visited : 1;
unsigned used_flag : 1;
unsigned nothrow_flag : 1;
unsigned static_flag : 1;
unsigned public_flag : 1;
unsigned private_flag : 1;
unsigned protected_flag : 1;
unsigned deprecated_flag : 1;
unsigned default_def_flag : 1;
union {
struct {
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_2 : 1;
unsigned lang_flag_3 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
unsigned saturating_flag : 1;
unsigned unsigned_flag : 1;
unsigned packed_flag : 1;
unsigned user_align : 1;
unsigned nameless_flag : 1;
unsigned atomic_flag : 1;
unsigned spare0 : 3;
unsigned spare1 : 8;
unsigned address_space : 8;
} bits;
struct {
unsigned char unextended;
unsigned char extended;
unsigned char offset;
} int_length;
int length;
struct {
unsigned int log2_npatterns : 8;
unsigned int nelts_per_pattern : 8;
unsigned int unused : 16;
} vector_cst;
unsigned int version;
unsigned int chrec_var;
enum internal_fn ifn;
enum omp_memory_order omp_atomic_memory_order;
# 1066 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
struct {
unsigned short clique;
unsigned short base;
} dependence_info;
} u;
};
# 1371 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
struct tree_typed {
struct tree_base base;
tree type;
};
struct tree_common {
struct tree_typed typed;
tree chain;
};
struct tree_int_cst {
struct tree_typed typed;
long val[1];
};
struct tree_real_cst {
struct tree_typed typed;
struct real_value * real_cst_ptr;
};
struct tree_fixed_cst {
struct tree_typed typed;
struct fixed_value * fixed_cst_ptr;
};
struct tree_string {
struct tree_typed typed;
int length;
char str[1];
};
struct tree_complex {
struct tree_typed typed;
tree real;
tree imag;
};
struct tree_vector {
struct tree_typed typed;
tree elts[1];
};
struct tree_poly_int_cst {
struct tree_typed typed;
tree coeffs[1];
};
struct tree_identifier {
struct tree_common common;
struct ht_identifier id;
};
struct tree_list {
struct tree_common common;
tree purpose;
tree value;
};
struct tree_vec {
struct tree_common common;
tree a[1];
};
struct constructor_elt {
tree index;
tree value;
};
struct tree_constructor {
struct tree_typed typed;
vec<constructor_elt, va_gc> *elts;
};
enum omp_clause_depend_kind
{
OMP_CLAUSE_DEPEND_IN,
OMP_CLAUSE_DEPEND_OUT,
OMP_CLAUSE_DEPEND_INOUT,
OMP_CLAUSE_DEPEND_MUTEXINOUTSET,
OMP_CLAUSE_DEPEND_SOURCE,
OMP_CLAUSE_DEPEND_SINK,
OMP_CLAUSE_DEPEND_DEPOBJ,
OMP_CLAUSE_DEPEND_LAST
};
enum omp_clause_proc_bind_kind
{
OMP_CLAUSE_PROC_BIND_FALSE = 0,
OMP_CLAUSE_PROC_BIND_TRUE = 1,
OMP_CLAUSE_PROC_BIND_MASTER = 2,
OMP_CLAUSE_PROC_BIND_CLOSE = 3,
OMP_CLAUSE_PROC_BIND_SPREAD = 4,
OMP_CLAUSE_PROC_BIND_LAST
};
enum omp_clause_device_type_kind
{
OMP_CLAUSE_DEVICE_TYPE_HOST = 1,
OMP_CLAUSE_DEVICE_TYPE_NOHOST = 2,
OMP_CLAUSE_DEVICE_TYPE_ANY = 3
};
enum omp_clause_linear_kind
{
OMP_CLAUSE_LINEAR_DEFAULT,
OMP_CLAUSE_LINEAR_REF,
OMP_CLAUSE_LINEAR_VAL,
OMP_CLAUSE_LINEAR_UVAL
};
struct tree_exp {
struct tree_typed typed;
location_t locus;
tree
operands[1];
};
struct ssa_use_operand_t {
struct ssa_use_operand_t* prev;
struct ssa_use_operand_t* next;
union { gimple *stmt; tree ssa_name; } loc;
tree * use;
};
struct tree_ssa_name {
struct tree_typed typed;
tree var;
gimple *def_stmt;
union ssa_name_info_type {
struct ptr_info_def *ptr_info;
struct range_info_def *range_info;
}
info;
struct ssa_use_operand_t imm_uses;
};
struct phi_arg_d {
struct ssa_use_operand_t imm_use;
tree def;
location_t locus;
};
struct tree_omp_clause {
struct tree_common common;
location_t locus;
enum omp_clause_code code;
union omp_clause_subcode {
enum omp_clause_default_kind default_kind;
enum omp_clause_schedule_kind schedule_kind;
enum omp_clause_depend_kind depend_kind;
unsigned int map_kind;
enum omp_clause_proc_bind_kind proc_bind_kind;
enum tree_code reduction_code;
enum omp_clause_linear_kind linear_kind;
enum tree_code if_modifier;
enum omp_clause_defaultmap_kind defaultmap_kind;
enum omp_clause_bind_kind bind_kind;
enum omp_clause_device_type_kind device_type_kind;
} subcode;
gimple_seq gimple_reduction_init;
gimple_seq gimple_reduction_merge;
tree
ops[1];
};
struct tree_block {
struct tree_base base;
tree chain;
unsigned block_num;
location_t locus;
location_t end_locus;
tree vars;
vec<tree, va_gc> *nonlocalized_vars;
tree subblocks;
tree supercontext;
tree abstract_origin;
tree fragment_origin;
tree fragment_chain;
struct die_struct *die;
};
struct tree_type_common {
struct tree_common common;
tree size;
tree size_unit;
tree attributes;
unsigned int uid;
unsigned int precision : 10;
unsigned no_force_blk_flag : 1;
unsigned needs_constructing_flag : 1;
unsigned transparent_aggr_flag : 1;
unsigned restrict_flag : 1;
unsigned contains_placeholder_bits : 2;
enum machine_mode mode : 8;
unsigned string_flag : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_2 : 1;
unsigned lang_flag_3 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
unsigned align : 6;
unsigned warn_if_not_align : 6;
unsigned typeless_storage : 1;
unsigned empty_flag : 1;
unsigned indivisible_p : 1;
unsigned spare : 16;
alias_set_type alias_set;
tree pointer_to;
tree reference_to;
union tree_type_symtab {
int address;
struct die_struct * die;
} symtab;
tree canonical;
tree next_variant;
tree main_variant;
tree context;
tree name;
};
struct tree_type_with_lang_specific {
struct tree_type_common common;
struct lang_type *lang_specific;
};
struct tree_type_non_common {
struct tree_type_with_lang_specific with_lang_specific;
tree values;
tree minval;
tree maxval;
tree lang_1;
};
struct tree_binfo {
struct tree_common common;
tree offset;
tree vtable;
tree virtuals;
tree vptr_field;
vec<tree, va_gc> *base_accesses;
tree inheritance;
tree vtt_subvtt;
tree vtt_vptr;
vec<tree, va_gc> base_binfos;
};
struct tree_decl_minimal {
struct tree_common common;
location_t locus;
unsigned int uid;
tree name;
tree context;
};
struct tree_decl_common {
struct tree_decl_minimal common;
tree size;
enum machine_mode mode : 8;
unsigned nonlocal_flag : 1;
unsigned virtual_flag : 1;
unsigned ignored_flag : 1;
unsigned abstract_flag : 1;
unsigned artificial_flag : 1;
unsigned preserve_flag: 1;
unsigned debug_expr_is_from : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_2 : 1;
unsigned lang_flag_3 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
unsigned lang_flag_8 : 1;
unsigned decl_flag_0 : 1;
unsigned decl_flag_1 : 1;
unsigned decl_flag_2 : 1;
unsigned decl_flag_3 : 1;
unsigned not_gimple_reg_flag : 1;
unsigned decl_by_reference_flag : 1;
unsigned decl_read_flag : 1;
unsigned decl_nonshareable_flag : 1;
unsigned int off_align : 6;
unsigned int align : 6;
unsigned int warn_if_not_align : 6;
unsigned int pt_uid;
tree size_unit;
tree initial;
tree attributes;
tree abstract_origin;
struct lang_decl *lang_specific;
};
struct tree_decl_with_rtl {
struct tree_decl_common common;
rtx rtl;
};
struct tree_field_decl {
struct tree_decl_common common;
tree offset;
tree bit_field_type;
tree qualifier;
tree bit_offset;
tree fcontext;
};
struct tree_label_decl {
struct tree_decl_with_rtl common;
int label_decl_uid;
int eh_landing_pad_nr;
};
struct tree_result_decl {
struct tree_decl_with_rtl common;
};
struct tree_const_decl {
struct tree_decl_common common;
};
struct tree_parm_decl {
struct tree_decl_with_rtl common;
rtx incoming_rtl;
};
struct tree_decl_with_vis {
struct tree_decl_with_rtl common;
tree assembler_name;
struct symtab_node *symtab_node;
unsigned defer_output : 1;
unsigned hard_register : 1;
unsigned common_flag : 1;
unsigned in_text_section : 1;
unsigned in_constant_pool : 1;
unsigned dllimport_flag : 1;
unsigned weak_flag : 1;
unsigned seen_in_bind_expr : 1;
unsigned comdat_flag : 1;
enum symbol_visibility visibility : 2;
unsigned visibility_specified : 1;
unsigned init_priority_p : 1;
unsigned shadowed_for_var_p : 1;
unsigned cxx_constructor : 1;
unsigned cxx_destructor : 1;
unsigned final : 1;
unsigned regdecl_flag : 1;
};
struct tree_var_decl {
struct tree_decl_with_vis common;
};
struct tree_decl_non_common {
struct tree_decl_with_vis common;
tree result;
};
enum function_decl_type
{
NONE,
OPERATOR_NEW,
OPERATOR_DELETE,
LAMBDA_FUNCTION
};
struct tree_function_decl {
struct tree_decl_non_common common;
struct function *f;
tree arguments;
tree personality;
tree function_specific_target;
tree function_specific_optimization;
tree saved_tree;
tree vindex;
unsigned int function_code;
enum built_in_class built_in_class : 2;
unsigned static_ctor_flag : 1;
unsigned static_dtor_flag : 1;
unsigned uninlinable : 1;
unsigned possibly_inlined : 1;
unsigned novops_flag : 1;
unsigned returns_twice_flag : 1;
unsigned malloc_flag : 1;
unsigned declared_inline_flag : 1;
unsigned no_inline_warning_flag : 1;
unsigned no_instrument_function_entry_exit : 1;
unsigned no_limit_stack : 1;
unsigned disregard_inline_limits : 1;
unsigned pure_flag : 1;
unsigned looping_const_or_pure_flag : 1;
enum function_decl_type decl_type: 2;
unsigned has_debug_args_flag : 1;
unsigned versioned_function : 1;
unsigned replaceable_operator : 1;
};
struct tree_translation_unit_decl {
struct tree_decl_common common;
const char * language;
};
struct tree_type_decl {
struct tree_decl_non_common common;
};
struct tree_statement_list_node
{
struct tree_statement_list_node *prev;
struct tree_statement_list_node *next;
tree stmt;
};
struct tree_statement_list
{
struct tree_typed typed;
struct tree_statement_list_node *head;
struct tree_statement_list_node *tail;
};
struct tree_optimization_option {
struct tree_base base;
struct cl_optimization *opts;
void * optabs;
struct target_optabs * base_optabs;
};
class target_globals;
struct tree_target_option {
struct tree_base base;
class target_globals *globals;
struct cl_target_option *opts;
};
union
tree_node {
struct tree_base base;
struct tree_typed typed;
struct tree_common common;
struct tree_int_cst int_cst;
struct tree_poly_int_cst poly_int_cst;
struct tree_real_cst real_cst;
struct tree_fixed_cst fixed_cst;
struct tree_vector vector;
struct tree_string string;
struct tree_complex complex;
struct tree_identifier identifier;
struct tree_decl_minimal decl_minimal;
struct tree_decl_common decl_common;
struct tree_decl_with_rtl decl_with_rtl;
struct tree_decl_non_common
decl_non_common;
struct tree_parm_decl parm_decl;
struct tree_decl_with_vis decl_with_vis;
struct tree_var_decl var_decl;
struct tree_field_decl field_decl;
struct tree_label_decl label_decl;
struct tree_result_decl result_decl;
struct tree_const_decl const_decl;
struct tree_type_decl type_decl;
struct tree_function_decl function_decl;
struct tree_translation_unit_decl
translation_unit_decl;
struct tree_type_common type_common;
struct tree_type_with_lang_specific
type_with_lang_specific;
struct tree_type_non_common
type_non_common;
struct tree_list list;
struct tree_vec vec;
struct tree_exp exp;
struct tree_ssa_name ssa_name;
struct tree_block block;
struct tree_binfo binfo;
struct tree_statement_list stmt_list;
struct tree_constructor constructor;
struct tree_omp_clause omp_clause;
struct tree_optimization_option optimization;
struct tree_target_option target_option;
};
struct attribute_spec {
const char *name;
int min_length;
int max_length;
bool decl_required;
bool type_required;
bool function_type_required;
bool affects_type_identity;
# 2054 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-core.h"
tree (*handler) (tree *node, tree name, tree args,
int flags, bool *no_add_attrs);
struct exclusions {
const char *name;
bool function;
bool variable;
bool type;
};
const exclusions *exclude;
};
typedef struct record_layout_info_s {
tree t;
tree offset;
unsigned int offset_align;
tree bitpos;
unsigned int record_align;
unsigned int unpacked_align;
tree prev_field;
vec<tree, va_gc> *pending_statics;
int remaining_in_alignment;
int packed_maybe_necessary;
} *record_layout_info;
struct function_args_iterator {
tree next;
};
struct tree_map_base {
tree from;
};
struct tree_map {
struct tree_map_base base;
unsigned int hash;
tree to;
};
struct tree_decl_map {
struct tree_map_base base;
tree to;
};
struct tree_int_map {
struct tree_map_base base;
unsigned int to;
};
struct tree_vec_map {
struct tree_map_base base;
vec<tree, va_gc> *to;
};
struct call_expr_arg_iterator {
tree t;
int n;
int i;
};
struct const_call_expr_arg_iterator {
const_tree t;
int n;
int i;
};
struct builtin_info_type {
tree decl;
unsigned implicit_p : 1;
unsigned declared_p : 1;
};
struct floatn_type_info {
int n;
bool extended;
};
extern bool tree_contains_struct[MAX_TREE_CODES][64];
extern const enum tree_code_class tree_code_type[];
extern const char *const tree_code_class_strings[];
extern const unsigned char tree_code_length[];
extern vec<alias_pair, va_gc> *alias_pairs;
extern const char *const built_in_class_names[(BUILT_IN_NORMAL + 1)];
extern const char * built_in_names[(int) END_BUILTINS];
extern unsigned const char omp_clause_num_ops[];
extern const char * const omp_clause_code_name[];
extern vec<tree, va_gc> *all_translation_units;
extern tree global_trees[TI_MAX];
extern tree integer_types[itk_none];
extern tree sizetype_tab[(int) stk_type_kind_last];
extern uint64_t tree_node_counts[];
extern uint64_t tree_node_sizes[];
extern bool in_gimple_form;
extern builtin_info_type builtin_info[(int)END_BUILTINS];
extern unsigned int maximum_field_alignment;
extern tree current_function_decl;
extern const char * current_function_func_begin_label;
extern const floatn_type_info floatn_nx_types[(TI_FLOATN_NX_TYPE_LAST - TI_FLOATN_NX_TYPE_FIRST + 1)];
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h" 2
inline combined_fn
as_combined_fn (built_in_function fn)
{
return combined_fn (int (fn));
}
inline combined_fn
as_combined_fn (internal_fn fn)
{
return combined_fn (int (fn) + int (END_BUILTINS));
}
inline bool
builtin_fn_p (combined_fn code)
{
return int (code) < int (END_BUILTINS);
}
inline built_in_function
as_builtin_fn (combined_fn code)
{
((void)(!(builtin_fn_p (code)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 55, __FUNCTION__), 0 : 0));
return built_in_function (int (code));
}
inline bool
internal_fn_p (combined_fn code)
{
return int (code) >= int (END_BUILTINS);
}
inline internal_fn
as_internal_fn (combined_fn code)
{
((void)(!(internal_fn_p (code)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 73, __FUNCTION__), 0 : 0));
return internal_fn (int (code) - int (END_BUILTINS));
}
# 351 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern void tree_contains_struct_check_failed (const_tree,
const enum tree_node_structure_enum,
const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_check_failed (const_tree, const char *, int, const char *,
...) __attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_not_check_failed (const_tree, const char *, int, const char *,
...) __attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_class_check_failed (const_tree, const enum tree_code_class,
const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_range_check_failed (const_tree, const char *, int,
const char *, enum tree_code,
enum tree_code)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_not_class_check_failed (const_tree,
const enum tree_code_class,
const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_int_cst_elt_check_failed (int, int, const char *,
int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_vec_elt_check_failed (int, int, const char *,
int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void phi_node_elt_check_failed (int, int, const char *,
int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void tree_operand_check_failed (int, const_tree,
const char *, int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void omp_clause_check_failed (const_tree, const char *, int,
const char *, enum omp_clause_code)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void omp_clause_operand_check_failed (int, const_tree, const char *,
int, const char *)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
extern void omp_clause_range_check_failed (const_tree, const char *, int,
const char *, enum omp_clause_code,
enum omp_clause_code)
__attribute__ ((__noreturn__)) __attribute__ ((__cold__));
# 428 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
# 1 "./tree-check.h" 1
# 429 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h" 2
# 1200 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
static inline source_range
get_expr_source_range (tree expr)
{
location_t loc = ((((expr)) && ((tree_code_type[(int) (((enum tree_code) ((expr))->base.code))]) >= tcc_reference && (tree_code_type[(int) (((enum tree_code) ((expr))->base.code))]) <= tcc_expression)) ? (expr)->exp.locus : ((location_t) 0));
return get_range_from_loc (line_table, loc);
}
extern void protected_set_expr_location (tree, location_t);
extern void protected_set_expr_location_if_unset (tree, location_t);
extern tree maybe_wrap_with_location (tree, location_t);
extern int suppress_location_wrappers;
class auto_suppress_location_wrappers
{
public:
auto_suppress_location_wrappers () { ++suppress_location_wrappers; }
~auto_suppress_location_wrappers () { --suppress_location_wrappers; }
};
# 1996 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern machine_mode element_mode (const_tree);
extern machine_mode vector_type_mode (const_tree);
extern unsigned int vector_element_bits (const_tree);
extern tree vector_element_bits_tree (const_tree);
# 2653 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree decl_value_expr_lookup (tree);
extern void decl_value_expr_insert (tree, tree);
# 2940 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree decl_debug_expr_lookup (tree);
extern void decl_debug_expr_insert (tree, tree);
# 2952 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern priority_type decl_init_priority_lookup (tree);
extern priority_type decl_fini_priority_lookup (tree);
extern void decl_init_priority_insert (tree, priority_type);
extern void decl_fini_priority_insert (tree, priority_type);
# 3035 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
static inline void
set_function_decl_type (tree decl, function_decl_type t, bool set)
{
if (set)
{
((void)(!((decl->function_decl.decl_type) == NONE || (decl->function_decl.decl_type) == t) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3040, __FUNCTION__), 0 : 0))
;
decl->function_decl.decl_type = t;
}
else if ((decl->function_decl.decl_type) == t)
(decl->function_decl.decl_type) = NONE;
}
# 3169 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern vec<tree, va_gc> **decl_debug_args_lookup (tree);
extern vec<tree, va_gc> **decl_debug_args_insert (tree);
# 3276 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree build_optimization_node (struct gcc_options *opts);
# 3285 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree build_target_option_node (struct gcc_options *opts);
extern void prepare_target_option_nodes_for_pch (void);
inline tree
tree_check (tree __t, const char *__f, int __l, const char *__g, tree_code __c)
{
if (((enum tree_code) (__t)->base.code) != __c)
tree_check_failed (__t, __f, __l, __g, __c, 0);
return __t;
}
inline tree
tree_not_check (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c)
{
if (((enum tree_code) (__t)->base.code) == __c)
tree_not_check_failed (__t, __f, __l, __g, __c, 0);
return __t;
}
inline tree
tree_check2 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
return __t;
}
inline tree
tree_not_check2 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
return __t;
}
inline tree
tree_check3 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2
&& ((enum tree_code) (__t)->base.code) != __c3)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
return __t;
}
inline tree
tree_not_check3 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2
|| ((enum tree_code) (__t)->base.code) == __c3)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
return __t;
}
inline tree
tree_check4 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2
&& ((enum tree_code) (__t)->base.code) != __c3
&& ((enum tree_code) (__t)->base.code) != __c4)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
return __t;
}
inline tree
tree_not_check4 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2
|| ((enum tree_code) (__t)->base.code) == __c3
|| ((enum tree_code) (__t)->base.code) == __c4)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
return __t;
}
inline tree
tree_check5 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4, enum tree_code __c5)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2
&& ((enum tree_code) (__t)->base.code) != __c3
&& ((enum tree_code) (__t)->base.code) != __c4
&& ((enum tree_code) (__t)->base.code) != __c5)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
return __t;
}
inline tree
tree_not_check5 (tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4, enum tree_code __c5)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2
|| ((enum tree_code) (__t)->base.code) == __c3
|| ((enum tree_code) (__t)->base.code) == __c4
|| ((enum tree_code) (__t)->base.code) == __c5)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
return __t;
}
inline tree
contains_struct_check (tree __t, const enum tree_node_structure_enum __s,
const char *__f, int __l, const char *__g)
{
if (tree_contains_struct[((enum tree_code) (__t)->base.code)][__s] != 1)
tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
return __t;
}
inline tree
tree_class_check (tree __t, const enum tree_code_class __class,
const char *__f, int __l, const char *__g)
{
if (tree_code_type[(int) (((enum tree_code) (__t)->base.code))] != __class)
tree_class_check_failed (__t, __class, __f, __l, __g);
return __t;
}
inline tree
tree_range_check (tree __t,
enum tree_code __code1, enum tree_code __code2,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) < __code1 || ((enum tree_code) (__t)->base.code) > __code2)
tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
return __t;
}
inline tree
omp_clause_subcode_check (tree __t, enum omp_clause_code __code,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != OMP_CLAUSE)
tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
if (__t->omp_clause.code != __code)
omp_clause_check_failed (__t, __f, __l, __g, __code);
return __t;
}
inline tree
omp_clause_range_check (tree __t,
enum omp_clause_code __code1,
enum omp_clause_code __code2,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != OMP_CLAUSE)
tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
if ((int) __t->omp_clause.code < (int) __code1
|| (int) __t->omp_clause.code > (int) __code2)
omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
return __t;
}
inline tree
expr_check (tree __t, const char *__f, int __l, const char *__g)
{
char const __c = tree_code_type[(int) (((enum tree_code) (__t)->base.code))];
if (!((__c) >= tcc_reference && (__c) <= tcc_expression))
tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
return __t;
}
inline tree
non_type_check (tree __t, const char *__f, int __l, const char *__g)
{
if ((tree_code_type[(int) (((enum tree_code) (__t)->base.code))] == tcc_type))
tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
return __t;
}
inline const long *
tree_int_cst_elt_check (const_tree __t, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != INTEGER_CST)
tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
if (__i < 0 || __i >= __t->base.u.int_length.extended)
tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
__f, __l, __g);
return &(const_cast<union tree_node *> (((__t))))->int_cst.val[__i];
}
inline long *
tree_int_cst_elt_check (tree __t, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != INTEGER_CST)
tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
if (__i < 0 || __i >= __t->base.u.int_length.extended)
tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
__f, __l, __g);
return &(const_cast<union tree_node *> (((__t))))->int_cst.val[__i];
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-overflow"
inline tree *
tree_vec_elt_check (tree __t, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != TREE_VEC)
tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
if (__i < 0 || __i >= __t->base.u.length)
tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
return &(const_cast<union tree_node *> (((__t))))->vec.a[__i];
}
#pragma GCC diagnostic pop
inline tree *
omp_clause_elt_check (tree __t, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != OMP_CLAUSE)
tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
return &__t->omp_clause.ops[__i];
}
inline tree
any_integral_type_check (tree __t, const char *__f, int __l, const char *__g)
{
if (!((((enum tree_code) (__t)->base.code) == ENUMERAL_TYPE || ((enum tree_code) (__t)->base.code) == BOOLEAN_TYPE || ((enum tree_code) (__t)->base.code) == INTEGER_TYPE) || ((((enum tree_code) (__t)->base.code) == COMPLEX_TYPE || (((enum tree_code) (__t)->base.code) == VECTOR_TYPE)) && (((enum tree_code) (((contains_struct_check ((__t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3540, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check ((__t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3540, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code) (((contains_struct_check ((__t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3540, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE))))
tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
INTEGER_TYPE, 0);
return __t;
}
inline const_tree
tree_check (const_tree __t, const char *__f, int __l, const char *__g,
tree_code __c)
{
if (((enum tree_code) (__t)->base.code) != __c)
tree_check_failed (__t, __f, __l, __g, __c, 0);
return __t;
}
inline const_tree
tree_not_check (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c)
{
if (((enum tree_code) (__t)->base.code) == __c)
tree_not_check_failed (__t, __f, __l, __g, __c, 0);
return __t;
}
inline const_tree
tree_check2 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
return __t;
}
inline const_tree
tree_not_check2 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
return __t;
}
inline const_tree
tree_check3 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2
&& ((enum tree_code) (__t)->base.code) != __c3)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
return __t;
}
inline const_tree
tree_not_check3 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2
|| ((enum tree_code) (__t)->base.code) == __c3)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
return __t;
}
inline const_tree
tree_check4 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2
&& ((enum tree_code) (__t)->base.code) != __c3
&& ((enum tree_code) (__t)->base.code) != __c4)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
return __t;
}
inline const_tree
tree_not_check4 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2
|| ((enum tree_code) (__t)->base.code) == __c3
|| ((enum tree_code) (__t)->base.code) == __c4)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
return __t;
}
inline const_tree
tree_check5 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4, enum tree_code __c5)
{
if (((enum tree_code) (__t)->base.code) != __c1
&& ((enum tree_code) (__t)->base.code) != __c2
&& ((enum tree_code) (__t)->base.code) != __c3
&& ((enum tree_code) (__t)->base.code) != __c4
&& ((enum tree_code) (__t)->base.code) != __c5)
tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
return __t;
}
inline const_tree
tree_not_check5 (const_tree __t, const char *__f, int __l, const char *__g,
enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
enum tree_code __c4, enum tree_code __c5)
{
if (((enum tree_code) (__t)->base.code) == __c1
|| ((enum tree_code) (__t)->base.code) == __c2
|| ((enum tree_code) (__t)->base.code) == __c3
|| ((enum tree_code) (__t)->base.code) == __c4
|| ((enum tree_code) (__t)->base.code) == __c5)
tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
return __t;
}
inline const_tree
contains_struct_check (const_tree __t, const enum tree_node_structure_enum __s,
const char *__f, int __l, const char *__g)
{
if (tree_contains_struct[((enum tree_code) (__t)->base.code)][__s] != 1)
tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
return __t;
}
inline const_tree
tree_class_check (const_tree __t, const enum tree_code_class __class,
const char *__f, int __l, const char *__g)
{
if (tree_code_type[(int) (((enum tree_code) (__t)->base.code))] != __class)
tree_class_check_failed (__t, __class, __f, __l, __g);
return __t;
}
inline const_tree
tree_range_check (const_tree __t,
enum tree_code __code1, enum tree_code __code2,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) < __code1 || ((enum tree_code) (__t)->base.code) > __code2)
tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
return __t;
}
inline const_tree
omp_clause_subcode_check (const_tree __t, enum omp_clause_code __code,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != OMP_CLAUSE)
tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
if (__t->omp_clause.code != __code)
omp_clause_check_failed (__t, __f, __l, __g, __code);
return __t;
}
inline const_tree
omp_clause_range_check (const_tree __t,
enum omp_clause_code __code1,
enum omp_clause_code __code2,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != OMP_CLAUSE)
tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
if ((int) __t->omp_clause.code < (int) __code1
|| (int) __t->omp_clause.code > (int) __code2)
omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
return __t;
}
inline const_tree
expr_check (const_tree __t, const char *__f, int __l, const char *__g)
{
char const __c = tree_code_type[(int) (((enum tree_code) (__t)->base.code))];
if (!((__c) >= tcc_reference && (__c) <= tcc_expression))
tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
return __t;
}
inline const_tree
non_type_check (const_tree __t, const char *__f, int __l, const char *__g)
{
if ((tree_code_type[(int) (((enum tree_code) (__t)->base.code))] == tcc_type))
tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
return __t;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-overflow"
inline const_tree *
tree_vec_elt_check (const_tree __t, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != TREE_VEC)
tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
if (__i < 0 || __i >= __t->base.u.length)
tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
return (const_cast<const_tree *> ((&__t->vec.a[__i])));
}
#pragma GCC diagnostic pop
inline const_tree *
omp_clause_elt_check (const_tree __t, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != OMP_CLAUSE)
tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
return (const_cast<const_tree *> ((&__t->omp_clause.ops[__i])));
}
inline const_tree
any_integral_type_check (const_tree __t, const char *__f, int __l,
const char *__g)
{
if (!((((enum tree_code) (__t)->base.code) == ENUMERAL_TYPE || ((enum tree_code) (__t)->base.code) == BOOLEAN_TYPE || ((enum tree_code) (__t)->base.code) == INTEGER_TYPE) || ((((enum tree_code) (__t)->base.code) == COMPLEX_TYPE || (((enum tree_code) (__t)->base.code) == VECTOR_TYPE)) && (((enum tree_code) (((contains_struct_check ((__t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3766, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check ((__t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3766, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code) (((contains_struct_check ((__t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3766, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE))))
tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
INTEGER_TYPE, 0);
return __t;
}
static inline int
tree_operand_length (const_tree node)
{
if ((tree_code_type[(int) (((enum tree_code) (node)->base.code))] == tcc_vl_exp))
return ((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check ((node), (tcc_vl_exp), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3781, __FUNCTION__))->exp.operands[0]), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3781, __FUNCTION__))));
else
return tree_code_length[(int) (((enum tree_code) (node)->base.code))];
}
inline tree *
tree_operand_check (tree __t, int __i,
const char *__f, int __l, const char *__g)
{
const_tree __u = (expr_check ((__t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3793, __FUNCTION__));
if (__i < 0 || __i >= tree_operand_length (__u))
tree_operand_check_failed (__i, __u, __f, __l, __g);
return &(const_cast<union tree_node *> (((__u))))->exp.operands[__i];
}
inline tree *
tree_operand_check_code (tree __t, enum tree_code __code, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != __code)
tree_check_failed (__t, __f, __l, __g, __code, 0);
if (__i < 0 || __i >= tree_operand_length (__t))
tree_operand_check_failed (__i, __t, __f, __l, __g);
return &__t->exp.operands[__i];
}
inline const_tree *
tree_operand_check (const_tree __t, int __i,
const char *__f, int __l, const char *__g)
{
const_tree __u = (expr_check ((__t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3814, __FUNCTION__));
if (__i < 0 || __i >= tree_operand_length (__u))
tree_operand_check_failed (__i, __u, __f, __l, __g);
return (const_cast<const_tree *> ((&__u->exp.operands[__i])));
}
inline const_tree *
tree_operand_check_code (const_tree __t, enum tree_code __code, int __i,
const char *__f, int __l, const char *__g)
{
if (((enum tree_code) (__t)->base.code) != __code)
tree_check_failed (__t, __f, __l, __g, __code, 0);
if (__i < 0 || __i >= tree_operand_length (__t))
tree_operand_check_failed (__i, __t, __f, __l, __g);
return (const_cast<const_tree *> ((&__t->exp.operands[__i])));
}
inline bool
id_equal (const_tree id, const char *str)
{
return !strcmp (((const char *) (tree_check ((id), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3838, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str), str);
}
inline bool
id_equal (const char *str, const_tree id)
{
return !strcmp (str, ((const char *) (tree_check ((id), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3844, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str));
}
inline poly_uint64
TYPE_VECTOR_SUBPARTS (const_tree node)
{
static_assert ((1 <= 2), "NUM_POLY_INT_COEFFS <= 2");
unsigned int precision = (tree_check ((node), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3853, __FUNCTION__, (VECTOR_TYPE)))->type_common.precision;
if (1 == 2)
{
poly_uint64 res = 0;
res.coeffs[0] = 1UL << (precision & 0xff);
if (precision & 0x100)
res.coeffs[1] = 1UL << (precision & 0xff);
return res;
}
else
return 1UL << precision;
}
inline void
SET_TYPE_VECTOR_SUBPARTS (tree node, poly_uint64 subparts)
{
static_assert ((1 <= 2), "NUM_POLY_INT_COEFFS <= 2");
unsigned long coeff0 = subparts.coeffs[0];
int index = exact_log2 (coeff0);
((void)(!(index >= 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3877, __FUNCTION__), 0 : 0));
if (1 == 2)
{
# 3895 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
unsigned long coeff1 = subparts.coeffs[1];
((void)(!(coeff1 == 0 || coeff1 == coeff0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3896, __FUNCTION__), 0 : 0));
(tree_check ((node), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3897, __FUNCTION__, (VECTOR_TYPE)))->type_common.precision
= index + (coeff1 != 0 ? 0x100 : 0);
}
else
(tree_check ((node), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3901, __FUNCTION__, (VECTOR_TYPE)))->type_common.precision = index;
}
static inline bool
valid_vector_subparts_p (poly_uint64 subparts)
{
unsigned long coeff0 = subparts.coeffs[0];
if (!pow2p_hwi (coeff0))
return false;
if (1 == 2)
{
unsigned long coeff1 = subparts.coeffs[1];
if (coeff1 != 0 && coeff1 != coeff0)
return false;
}
return true;
}
inline built_in_function
DECL_FUNCTION_CODE (const_tree decl)
{
const tree_function_decl &fndecl = (tree_check ((decl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3927, __FUNCTION__, (FUNCTION_DECL)))->function_decl;
((void)(!(fndecl.built_in_class == BUILT_IN_NORMAL) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3928, __FUNCTION__), 0 : 0));
return (built_in_function) fndecl.function_code;
}
inline int
DECL_MD_FUNCTION_CODE (const_tree decl)
{
const tree_function_decl &fndecl = (tree_check ((decl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3938, __FUNCTION__, (FUNCTION_DECL)))->function_decl;
((void)(!(fndecl.built_in_class == BUILT_IN_MD) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3939, __FUNCTION__), 0 : 0));
return fndecl.function_code;
}
inline int
DECL_FE_FUNCTION_CODE (const_tree decl)
{
const tree_function_decl &fndecl = (tree_check ((decl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3949, __FUNCTION__, (FUNCTION_DECL)))->function_decl;
((void)(!(fndecl.built_in_class == BUILT_IN_FRONTEND) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3950, __FUNCTION__), 0 : 0));
return fndecl.function_code;
}
inline void
set_decl_built_in_function (tree decl, built_in_class fclass,
unsigned int fcode)
{
tree_function_decl &fndecl = (tree_check ((decl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3960, __FUNCTION__, (FUNCTION_DECL)))->function_decl;
fndecl.built_in_class = fclass;
fndecl.function_code = fcode;
}
inline void
copy_decl_built_in_function (tree newdecl, const_tree olddecl)
{
tree_function_decl &newfndecl = (tree_check ((newdecl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3970, __FUNCTION__, (FUNCTION_DECL)))->function_decl;
const tree_function_decl &oldfndecl
= (tree_check ((olddecl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 3972, __FUNCTION__, (FUNCTION_DECL)))->function_decl;
newfndecl.built_in_class = oldfndecl.built_in_class;
newfndecl.function_code = oldfndecl.function_code;
}
# 3987 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
inline bool
location_wrapper_p (const_tree exp)
{
# 3998 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
if ((((enum tree_code) (exp)->base.code) == NON_LVALUE_EXPR
|| ((enum tree_code) (exp)->base.code) == VIEW_CONVERT_EXPR)
&& ((tree_check2 ((exp), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4000, __FUNCTION__, (NON_LVALUE_EXPR), (VIEW_CONVERT_EXPR)))->base.public_flag))
return true;
return false;
}
inline tree
tree_strip_any_location_wrapper (tree exp)
{
if (location_wrapper_p (exp))
return (*((const_cast<tree*> (tree_operand_check ((exp), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4011, __FUNCTION__)))));
else
return exp;
}
# 4253 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
inline unsigned int
vector_cst_encoded_nelts (const_tree t)
{
return (1U << ((tree_check ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4256, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns)) * ((tree_check ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4256, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern);
}
extern tree decl_assembler_name (tree);
extern void overwrite_decl_assembler_name (tree decl, tree name);
extern tree decl_comdat_group (const_tree);
extern tree decl_comdat_group_id (const_tree);
extern const char *decl_section_name (const_tree);
extern void set_decl_section_name (tree, const char *);
extern enum tls_model decl_tls_model (const_tree);
extern void set_decl_tls_model (tree, enum tls_model);
extern size_t tree_size (const_tree);
extern size_t tree_code_size (enum tree_code);
extern int allocate_decl_uid (void);
extern tree make_node (enum tree_code );
extern void free_node (tree);
extern tree copy_node (tree );
extern tree copy_list (tree);
extern tree build_case_label (tree, tree, tree);
extern tree make_tree_binfo (unsigned );
extern tree make_int_cst (int, int );
extern tree make_tree_vec (int );
extern tree grow_tree_vec (tree v, int );
extern tree build_nt (enum tree_code, ...);
extern tree build_nt_call_vec (tree, vec<tree, va_gc> *);
extern tree build0 (enum tree_code, tree );
extern tree build1 (enum tree_code, tree, tree );
extern tree build2 (enum tree_code, tree, tree, tree );
extern tree build3 (enum tree_code, tree, tree, tree, tree );
extern tree build4 (enum tree_code, tree, tree, tree, tree,
tree );
extern tree build5 (enum tree_code, tree, tree, tree, tree, tree,
tree );
static inline tree
build1_loc (location_t loc, enum tree_code code, tree type,
tree arg1 )
{
tree t = build1 (code, type, arg1 );
if (((t) && ((tree_code_type[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference && (tree_code_type[(int) (((enum tree_code) (t)->base.code))]) <= tcc_expression)))
(expr_check (((t)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4340, __FUNCTION__))->exp.locus = (loc);
return t;
}
static inline tree
build2_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1 )
{
tree t = build2 (code, type, arg0, arg1 );
if (((t) && ((tree_code_type[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference && (tree_code_type[(int) (((enum tree_code) (t)->base.code))]) <= tcc_expression)))
(expr_check (((t)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4350, __FUNCTION__))->exp.locus = (loc);
return t;
}
static inline tree
build3_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2 )
{
tree t = build3 (code, type, arg0, arg1, arg2 );
if (((t) && ((tree_code_type[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference && (tree_code_type[(int) (((enum tree_code) (t)->base.code))]) <= tcc_expression)))
(expr_check (((t)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4360, __FUNCTION__))->exp.locus = (loc);
return t;
}
static inline tree
build4_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2, tree arg3 )
{
tree t = build4 (code, type, arg0, arg1, arg2, arg3 );
if (((t) && ((tree_code_type[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference && (tree_code_type[(int) (((enum tree_code) (t)->base.code))]) <= tcc_expression)))
(expr_check (((t)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4370, __FUNCTION__))->exp.locus = (loc);
return t;
}
static inline tree
build5_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2, tree arg3, tree arg4 )
{
tree t = build5 (code, type, arg0, arg1, arg2, arg3,
arg4 );
if (((t) && ((tree_code_type[(int) (((enum tree_code) (t)->base.code))]) >= tcc_reference && (tree_code_type[(int) (((enum tree_code) (t)->base.code))]) <= tcc_expression)))
(expr_check (((t)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4381, __FUNCTION__))->exp.locus = (loc);
return t;
}
extern tree double_int_to_tree (tree, double_int);
extern tree wide_int_to_tree (tree type, const poly_wide_int_ref &cst);
extern tree force_fit_type (tree, const poly_wide_int_ref &, int, bool);
extern tree build_int_cst (tree, poly_int64);
extern tree build_int_cstu (tree type, poly_uint64);
extern tree build_int_cst_type (tree, poly_int64);
extern tree make_vector (unsigned, unsigned );
extern tree build_vector_from_ctor (tree, vec<constructor_elt, va_gc> *);
extern tree build_vector_from_val (tree, tree);
extern tree build_uniform_cst (tree, tree);
extern tree build_vec_series (tree, tree, tree);
extern tree build_index_vector (tree, poly_uint64, poly_uint64);
extern tree build_vector_a_then_b (tree, unsigned int, tree, tree);
extern void recompute_constructor_flags (tree);
extern void verify_constructor_flags (tree);
extern tree build_constructor (tree, vec<constructor_elt, va_gc> * );
extern tree build_constructor_single (tree, tree, tree);
extern tree build_constructor_from_list (tree, tree);
extern tree build_constructor_va (tree, int, ...);
extern tree build_clobber (tree);
extern tree build_real_from_int_cst (tree, const_tree);
extern tree build_complex (tree, tree, tree);
extern tree build_complex_inf (tree, bool);
extern tree build_each_one_cst (tree);
extern tree build_one_cst (tree);
extern tree build_minus_one_cst (tree);
extern tree build_all_ones_cst (tree);
extern tree build_zero_cst (tree);
extern tree build_string (unsigned, const char * = nullptr);
extern tree build_poly_int_cst (tree, const poly_wide_int_ref &);
extern tree build_tree_list (tree, tree );
extern tree build_tree_list_vec (const vec<tree, va_gc> * );
extern tree build_decl (location_t, enum tree_code,
tree, tree );
extern tree build_fn_decl (const char *, tree);
extern tree build_translation_unit_decl (tree);
extern tree build_block (tree, tree, tree, tree);
extern tree build_empty_stmt (location_t);
extern tree build_omp_clause (location_t, enum omp_clause_code);
extern tree build_vl_exp (enum tree_code, int );
extern tree build_call_nary (tree, tree, int, ...);
extern tree build_call_valist (tree, tree, int, va_list);
extern tree build_call_array_loc (location_t, tree, tree, int, const tree *);
extern tree build_call_vec (tree, tree, vec<tree, va_gc> *);
extern tree build_call_expr_loc_array (location_t, tree, int, tree *);
extern tree build_call_expr_loc_vec (location_t, tree, vec<tree, va_gc> *);
extern tree build_call_expr_loc (location_t, tree, int, ...);
extern tree build_call_expr (tree, int, ...);
extern tree build_call_expr_internal_loc (location_t, enum internal_fn,
tree, int, ...);
extern tree build_call_expr_internal_loc_array (location_t, enum internal_fn,
tree, int, const tree *);
extern tree maybe_build_call_expr_loc (location_t, combined_fn, tree,
int, ...);
extern tree build_alloca_call_expr (tree, unsigned int, long);
extern tree build_string_literal (unsigned, const char * = nullptr,
tree = integer_types[itk_char],
unsigned long = -1UL);
extern tree signed_or_unsigned_type_for (int, tree);
extern tree signed_type_for (tree);
extern tree unsigned_type_for (tree);
extern tree truth_type_for (tree);
extern tree build_pointer_type_for_mode (tree, machine_mode, bool);
extern tree build_pointer_type (tree);
extern tree build_reference_type_for_mode (tree, machine_mode, bool);
extern tree build_reference_type (tree);
extern tree build_vector_type_for_mode (tree, machine_mode);
extern tree build_vector_type (tree, poly_int64);
extern tree build_truth_vector_type_for_mode (poly_uint64, machine_mode);
extern tree build_opaque_vector_type (tree, poly_int64);
extern tree build_index_type (tree);
extern tree build_array_type (tree, tree, bool = false);
extern tree build_nonshared_array_type (tree, tree);
extern tree build_array_type_nelts (tree, poly_uint64);
extern tree build_function_type (tree, tree);
extern tree build_function_type_list (tree, ...);
extern tree build_varargs_function_type_list (tree, ...);
extern tree build_function_type_array (tree, int, tree *);
extern tree build_varargs_function_type_array (tree, int, tree *);
extern tree build_method_type_directly (tree, tree, tree);
extern tree build_method_type (tree, tree);
extern tree build_offset_type (tree, tree);
extern tree build_complex_type (tree, bool named = false);
extern tree array_type_nelts (const_tree);
extern tree value_member (tree, tree);
extern tree purpose_member (const_tree, tree);
extern bool vec_member (const_tree, vec<tree, va_gc> *);
extern tree chain_index (int, tree);
extern int tree_int_cst_equal (const_tree, const_tree);
extern bool tree_fits_shwi_p (const_tree) __attribute__ ((__pure__));
extern bool tree_fits_poly_int64_p (const_tree) __attribute__ ((__pure__));
extern bool tree_fits_uhwi_p (const_tree) __attribute__ ((__pure__));
extern bool tree_fits_poly_uint64_p (const_tree) __attribute__ ((__pure__));
extern long tree_to_shwi (const_tree)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__pure__));
extern poly_int64 tree_to_poly_int64 (const_tree)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__pure__));
extern unsigned long tree_to_uhwi (const_tree)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__pure__));
extern poly_uint64 tree_to_poly_uint64 (const_tree)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__pure__));
# 4541 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern int tree_int_cst_sgn (const_tree);
extern int tree_int_cst_sign_bit (const_tree);
extern unsigned int tree_int_cst_min_precision (tree, signop);
extern tree strip_array_types (tree);
extern tree excess_precision_type (tree);
enum cst_size_error {
cst_size_ok,
cst_size_not_constant,
cst_size_negative,
cst_size_too_big,
cst_size_overflow
};
extern bool valid_constant_size_p (const_tree, cst_size_error * = nullptr);
extern tree max_object_size ();
inline bool
poly_int_tree_p (const_tree t, poly_int64_pod *value)
{
if (tree_fits_poly_int64_p (t))
{
*value = tree_to_poly_int64 (t);
return true;
}
return false;
}
inline bool
poly_int_tree_p (const_tree t, poly_uint64_pod *value)
{
if (tree_fits_poly_uint64_p (t))
{
*value = tree_to_poly_uint64 (t);
return true;
}
return false;
}
extern tree make_tree (tree, rtx);
extern bool check_lang_type (const_tree cand, const_tree base);
extern bool check_base_type (const_tree cand, const_tree base);
extern bool check_qualified_type (const_tree, const_tree, int);
extern tree get_qualified_type (tree, int);
extern tree build_qualified_type (tree, int );
extern tree build_aligned_type (tree, unsigned int);
# 4635 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree build_distinct_type_copy (tree );
extern tree build_variant_type_copy (tree );
extern hashval_t type_hash_canon_hash (tree);
extern tree type_hash_canon (unsigned int, tree);
extern tree convert (tree, tree);
extern tree size_in_bytes_loc (location_t, const_tree);
inline tree
size_in_bytes (const_tree t)
{
return size_in_bytes_loc (input_location, t);
}
extern long int_size_in_bytes (const_tree);
extern long max_int_size_in_bytes (const_tree);
extern tree bit_position (const_tree);
extern tree byte_position (const_tree);
extern long int_byte_position (const_tree);
# 4685 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree chainon (tree, tree);
extern tree tree_cons (tree, tree, tree );
extern tree tree_last (tree);
extern tree nreverse (tree);
extern int list_length (const_tree);
extern tree first_field (const_tree) __attribute__ ((__nonnull__ (1)));
extern tree last_field (const_tree) __attribute__ ((__nonnull__ (1)));
# 4716 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern bool initializer_zerop (const_tree, bool * = nullptr);
extern bool initializer_each_zero_or_onep (const_tree);
extern wide_int vector_cst_int_elt (const_tree, unsigned int);
extern tree vector_cst_elt (const_tree, unsigned int);
extern tree uniform_vector_p (const_tree);
extern tree uniform_integer_cst_p (tree);
extern int single_nonzero_element (const_tree);
extern vec<tree, va_gc> *ctor_to_vec (tree);
extern bool zerop (const_tree);
extern bool integer_zerop (const_tree);
extern bool integer_onep (const_tree);
extern bool integer_each_onep (const_tree);
extern bool integer_all_onesp (const_tree);
extern bool integer_minus_onep (const_tree);
extern bool integer_pow2p (const_tree);
extern bool integer_nonzerop (const_tree);
extern bool integer_truep (const_tree);
extern bool cst_and_fits_in_hwi (const_tree);
extern tree num_ending_zeros (const_tree);
extern bool fixed_zerop (const_tree);
extern tree staticp (tree);
extern tree save_expr (tree);
extern bool tree_invariant_p (tree);
extern tree skip_simple_arithmetic (tree);
extern tree skip_simple_constant_arithmetic (tree);
enum tree_node_structure_enum tree_node_structure (const_tree);
extern bool contains_placeholder_p (const_tree);
# 4833 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern bool type_contains_placeholder_p (tree);
# 4842 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern void find_placeholder_in_expr (tree, vec<tree> *);
# 4860 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree substitute_in_expr (tree, tree, tree);
# 4871 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree substitute_placeholder_in_expr (tree, tree);
# 4885 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree stabilize_reference (tree);
extern tree get_unwidened (tree, tree);
extern tree get_narrower (tree, int *);
static inline bool
handled_component_p (const_tree t)
{
switch (((enum tree_code) (t)->base.code))
{
case COMPONENT_REF:
case BIT_FIELD_REF:
case ARRAY_REF:
case ARRAY_RANGE_REF:
case REALPART_EXPR:
case IMAGPART_EXPR:
case VIEW_CONVERT_EXPR:
return true;
default:
return false;
}
}
static inline bool
reverse_storage_order_for_component_p (tree t)
{
if ((((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4928, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE || (((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4928, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE || ((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4928, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE || ((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4928, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE)) || (((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4928, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE))
return false;
if (((enum tree_code) (t)->base.code) == REALPART_EXPR || ((enum tree_code) (t)->base.code) == IMAGPART_EXPR)
t = (*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4932, __FUNCTION__)))));
switch (((enum tree_code) (t)->base.code))
{
case ARRAY_REF:
case COMPONENT_REF:
return (((enum tree_code) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__)))))), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE || (((enum tree_code) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__)))))), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE || ((enum tree_code) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__)))))), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE || ((enum tree_code) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__)))))), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4940, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE))
&& ((tree_check4 ((((contains_struct_check (((*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4941, __FUNCTION__)))))), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4941, __FUNCTION__))->typed.type)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4941, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE)))->base.u.bits.saturating_flag);
case BIT_FIELD_REF:
case MEM_REF:
return ((tree_check2 ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4945, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag);
case ARRAY_RANGE_REF:
case VIEW_CONVERT_EXPR:
default:
return false;
}
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4953, __FUNCTION__));
}
static inline bool
storage_order_barrier_p (const_tree t)
{
if (((enum tree_code) (t)->base.code) != VIEW_CONVERT_EXPR)
return false;
if ((((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4968, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE || (((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4968, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE || ((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4968, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE || ((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4968, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE))
&& ((tree_check4 ((((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4969, __FUNCTION__))->typed.type)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4969, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
return true;
tree op = (*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4972, __FUNCTION__)))));
if ((((enum tree_code) (((contains_struct_check ((op), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4974, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE || (((enum tree_code) (((contains_struct_check ((op), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4974, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE || ((enum tree_code) (((contains_struct_check ((op), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4974, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE || ((enum tree_code) (((contains_struct_check ((op), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4974, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE))
&& ((tree_check4 ((((contains_struct_check ((op), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4975, __FUNCTION__))->typed.type)), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 4975, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
return true;
return false;
}
extern tree get_containing_scope (const_tree);
extern const_tree get_ultimate_context (const_tree);
extern tree decl_function_context (const_tree);
extern tree decl_type_context (const_tree);
extern bool real_zerop (const_tree);
static inline void
function_args_iter_init (function_args_iterator *i, const_tree fntype)
{
i->next = ((tree_check2 ((fntype), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5006, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common.values);
}
static inline tree *
function_args_iter_cond_ptr (function_args_iterator *i)
{
return (i->next) ? &((tree_check ((i->next), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5015, __FUNCTION__, (TREE_LIST)))->list.value) : nullptr;
}
static inline tree
function_args_iter_cond (function_args_iterator *i)
{
return (i->next) ? ((tree_check ((i->next), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5024, __FUNCTION__, (TREE_LIST)))->list.value) : (tree) nullptr;
}
static inline void
function_args_iter_next (function_args_iterator *i)
{
((void)(!(i->next != (tree) nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5031, __FUNCTION__), 0 : 0));
i->next = ((contains_struct_check ((i->next), (TS_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5032, __FUNCTION__))->common.chain);
}
static inline bool
inlined_function_outer_scope_p (const_tree block)
{
return ((IS_ADHOC_LOC (((tree_check ((block), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5040, __FUNCTION__, (BLOCK)))->block.locus))) ? get_location_from_adhoc_loc (line_table, ((tree_check ((block), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5040, __FUNCTION__, (BLOCK)))->block.locus)) : (((tree_check ((block), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5040, __FUNCTION__, (BLOCK)))->block.locus))) != ((location_t) 0);
}
# 5060 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern unsigned crc32_unsigned_n (unsigned, unsigned, unsigned);
extern unsigned crc32_string (unsigned, const char *);
inline unsigned
crc32_unsigned (unsigned chksum, unsigned value)
{
return crc32_unsigned_n (chksum, value, 4);
}
inline unsigned
crc32_byte (unsigned chksum, char byte)
{
return crc32_unsigned_n (chksum, byte, 1);
}
extern void clean_symbol_name (char *);
extern tree get_file_function_name (const char *);
extern tree get_callee_fndecl (const_tree);
extern combined_fn get_call_combined_fn (const_tree);
extern int type_num_arguments (const_tree);
extern tree type_argument_type (const_tree, unsigned) __attribute__ ((__nonnull__ (1)));
extern bool associative_tree_code (enum tree_code);
extern bool commutative_tree_code (enum tree_code);
extern bool commutative_ternary_tree_code (enum tree_code);
extern bool operation_can_overflow (enum tree_code);
extern bool operation_no_trapping_overflow (tree, enum tree_code);
extern tree upper_bound_in_type (tree, tree);
extern tree lower_bound_in_type (tree, tree);
extern int operand_equal_for_phi_arg_p (const_tree, const_tree);
extern tree create_artificial_label (location_t);
extern const char *get_name (tree);
extern bool stdarg_p (const_tree);
extern bool prototype_p (const_tree);
extern bool is_typedef_decl (const_tree x);
extern bool typedef_variant_p (const_tree);
extern bool auto_var_p (const_tree);
extern bool auto_var_in_fn_p (const_tree, const_tree);
extern tree build_low_bits_mask (tree, unsigned);
extern bool tree_nop_conversion_p (const_tree, const_tree);
extern tree tree_strip_nop_conversions (tree);
extern tree tree_strip_sign_nop_conversions (tree);
extern const_tree strip_invariant_refs (const_tree);
extern tree lhd_gcc_personality (void);
extern void assign_assembler_name_if_needed (tree);
extern bool warn_deprecated_use (tree, tree);
extern void cache_integer_cst (tree);
extern const char *combined_fn_name (combined_fn);
static inline int
struct_ptr_eq (const void *a, const void *b)
{
const void * const * x = (const void * const *) a;
const void * const * y = (const void * const *) b;
return *x == *y;
}
static inline hashval_t
struct_ptr_hash (const void *a)
{
const void * const * x = (const void * const *) a;
return (intptr_t)*x >> 4;
}
static inline bool
truth_value_p (enum tree_code code)
{
return (tree_code_type[(int) (code)] == tcc_comparison
|| code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
|| code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
|| code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
}
static inline bool
ptrofftype_p (tree type)
{
return ((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || ((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum tree_code) (type)->base.code) == INTEGER_TYPE)
&& ((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5140, __FUNCTION__))->type_common.precision) == ((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5140, __FUNCTION__))->type_common.precision)
&& ((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5141, __FUNCTION__))->base.u.bits.unsigned_flag) == ((tree_class_check ((sizetype_tab[(int) stk_sizetype]), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5141, __FUNCTION__))->base.u.bits.unsigned_flag));
}
static inline bool
complete_or_array_type_p (const_tree type)
{
return (((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5150, __FUNCTION__))->type_common.size) != (tree) nullptr)
|| (((enum tree_code) (type)->base.code) == ARRAY_TYPE
&& (((tree_class_check ((((contains_struct_check ((type), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5152, __FUNCTION__))->typed.type)), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5152, __FUNCTION__))->type_common.size) != (tree) nullptr));
}
inline bool
poly_int_tree_p (const_tree t)
{
return (((enum tree_code) (t)->base.code) == INTEGER_CST || (1 > 1 && ((enum tree_code) (t)->base.code) == POLY_INT_CST));
}
inline poly_uint64
bit_field_size (const_tree t)
{
return tree_to_poly_uint64 ((*((const_cast<tree*> (tree_operand_check ((t), (1), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5169, __FUNCTION__))))));
}
inline poly_uint64
bit_field_offset (const_tree t)
{
return tree_to_poly_uint64 ((*((const_cast<tree*> (tree_operand_check ((t), (2), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5178, __FUNCTION__))))));
}
extern tree strip_float_extensions (tree);
extern bool really_constant_p (const_tree);
extern bool ptrdiff_tree_p (const_tree, poly_int64_pod *);
extern bool decl_address_invariant_p (const_tree);
extern bool decl_address_ip_invariant_p (const_tree);
extern bool int_fits_type_p (const_tree, const_tree)
__attribute__ ((__nonnull__ (1))) __attribute__ ((__nonnull__ (2))) __attribute__ ((__pure__));
extern void get_type_static_bounds (const_tree, mpz_t, mpz_t);
extern bool variably_modified_type_p (tree, tree);
extern int tree_log2 (const_tree);
extern int tree_floor_log2 (const_tree);
extern unsigned int tree_ctz (const_tree);
extern int simple_cst_equal (const_tree, const_tree);
namespace inchash
{
extern void add_expr (const_tree, hash &, unsigned int = 0);
}
static inline hashval_t iterative_hash_expr(const_tree tree, hashval_t seed)
{
inchash::hash hstate (seed);
inchash::add_expr (tree, hstate);
return hstate.end ();
}
extern int compare_tree_int (const_tree, unsigned long);
extern bool type_list_equal (const_tree, const_tree);
extern bool chain_member (const_tree, const_tree);
extern void dump_tree_statistics (void);
extern void recompute_tree_invariant_for_addr_expr (tree);
extern bool needs_to_live_in_memory (const_tree);
extern tree reconstruct_complex_type (tree, tree);
extern bool real_onep (const_tree);
extern bool real_minus_onep (const_tree);
extern void init_ttree (void);
extern void build_common_tree_nodes (bool);
extern void build_common_builtin_nodes (void);
extern tree build_nonstandard_integer_type (unsigned long, int);
extern tree build_nonstandard_boolean_type (unsigned long);
extern tree build_range_type (tree, tree, tree);
extern tree build_nonshared_range_type (tree, tree, tree);
extern bool subrange_type_for_debug_p (const_tree, tree *, tree *);
extern long int_cst_value (const_tree);
extern tree tree_block (tree);
extern void tree_set_block (tree, tree);
extern location_t *block_nonartificial_location (tree);
extern location_t tree_nonartificial_location (tree);
extern tree block_ultimate_origin (const_tree);
extern tree get_binfo_at_offset (tree, poly_int64, tree);
extern bool virtual_method_call_p (const_tree, bool = false);
extern tree obj_type_ref_class (const_tree ref, bool = false);
extern bool types_same_for_odr (const_tree type1, const_tree type2);
extern bool contains_bitfld_component_ref_p (const_tree);
extern bool block_may_fallthru (const_tree);
extern void using_eh_for_cleanups (void);
extern bool using_eh_for_cleanups_p (void);
extern const char *get_tree_code_name (enum tree_code);
extern void set_call_expr_flags (tree, int);
extern tree walk_tree_1 (tree*, walk_tree_fn, void*, hash_set<tree>*,
walk_tree_lh);
extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*,
walk_tree_lh);
extern tree drop_tree_overflow (tree);
extern tree get_base_address (tree t);
extern tree array_ref_element_size (tree);
extern tree get_typenode_from_name (const char *);
extern tree array_ref_up_bound (tree);
extern tree array_ref_low_bound (tree);
extern bool array_at_struct_end_p (tree);
extern tree component_ref_field_offset (tree);
extern tree component_ref_size (tree, bool * = nullptr);
extern int tree_map_base_eq (const void *, const void *);
extern unsigned int tree_map_base_hash (const void *);
extern int tree_map_base_marked_p (const void *);
extern void __attribute__ ((__used__)) verify_type (const_tree t);
extern bool gimple_canonical_types_compatible_p (const_tree, const_tree,
bool trust_type_canonical = true);
extern bool type_with_interoperable_signedness (const_tree);
extern bitmap get_nonnull_args (const_tree);
extern int get_range_pos_neg (tree);
inline enum tree_code
tree_code_for_canonical_type_merging (enum tree_code code)
{
if (code == ENUMERAL_TYPE)
return INTEGER_TYPE;
if (code == REFERENCE_TYPE)
return POINTER_TYPE;
return code;
}
# 5335 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
inline bool
canonical_type_used_p (const_tree t)
{
return !((((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum tree_code) (t)->base.code) == REFERENCE_TYPE)
|| ((enum tree_code) (t)->base.code) == ARRAY_TYPE
|| ((enum tree_code) (t)->base.code) == VECTOR_TYPE);
}
extern unsigned int tree_map_hash (const void *);
extern unsigned int tree_decl_map_hash (const void *);
struct tree_decl_map_cache_hasher : ggc_cache_ptr_hash<tree_decl_map>
{
static hashval_t hash (tree_decl_map *m) { return tree_decl_map_hash (m); }
static bool
equal (tree_decl_map *a, tree_decl_map *b)
{
return tree_map_base_eq (a, b);
}
static int
keep_cache_entry (tree_decl_map *&m)
{
return ggc_marked_p (m->base.from);
}
};
# 5378 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
struct tree_decl_hash : ggc_ptr_hash <tree_node>
{
static inline hashval_t hash (tree);
};
inline hashval_t
tree_decl_hash::hash (tree t)
{
return ((contains_struct_check ((t), (TS_DECL_MINIMAL), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5386, __FUNCTION__))->decl_minimal.uid);
}
struct tree_type_hash : ggc_ptr_hash <tree_node>
{
static inline hashval_t hash (tree);
};
inline hashval_t
tree_type_hash::hash (tree t)
{
return ((tree_class_check ((t), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5398, __FUNCTION__))->type_common.uid);
}
struct tree_ssa_name_hash : ggc_ptr_hash <tree_node>
{
static inline hashval_t hash (tree);
};
inline hashval_t
tree_ssa_name_hash::hash (tree t)
{
return (tree_check ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5412, __FUNCTION__, (SSA_NAME)))->base.u.version;
}
struct tree_hash : ggc_ptr_hash <tree_node>
{
static hashval_t hash (tree);
};
inline hashval_t
tree_hash::hash (tree t)
{
return ((size_t) (t) & 0777777);
}
struct tree_cache_traits
: simple_cache_map_traits<default_hash_traits<tree>, tree> { };
typedef hash_map<tree,tree,tree_cache_traits> tree_cache_map;
struct decl_tree_cache_traits
: simple_cache_map_traits<tree_decl_hash, tree> { };
typedef hash_map<tree,tree,decl_tree_cache_traits> decl_tree_cache_map;
struct type_tree_cache_traits
: simple_cache_map_traits<tree_type_hash, tree> { };
typedef hash_map<tree,tree,type_tree_cache_traits> type_tree_cache_map;
static inline void
init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter)
{
iter->t = exp;
iter->n = (((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check ((exp), (tcc_vl_exp), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5452, __FUNCTION__))->exp.operands[0]), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5452, __FUNCTION__)))) - 3);
iter->i = 0;
}
static inline void
init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter)
{
iter->t = exp;
iter->n = (((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check ((exp), (tcc_vl_exp), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5460, __FUNCTION__))->exp.operands[0]), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5460, __FUNCTION__)))) - 3);
iter->i = 0;
}
static inline tree
next_call_expr_arg (call_expr_arg_iterator *iter)
{
tree result;
if (iter->i >= iter->n)
return (tree) nullptr;
result = (*((const_cast<tree*> (tree_operand_check (((tree_check ((iter->t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5472, __FUNCTION__, (CALL_EXPR)))), ((iter->i) + 3), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5472, __FUNCTION__)))));
iter->i++;
return result;
}
static inline const_tree
next_const_call_expr_arg (const_call_expr_arg_iterator *iter)
{
const_tree result;
if (iter->i >= iter->n)
return (tree) nullptr;
result = (*((const_cast<tree*> (tree_operand_check (((tree_check ((iter->t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5483, __FUNCTION__, (CALL_EXPR)))), ((iter->i) + 3), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5483, __FUNCTION__)))));
iter->i++;
return result;
}
static inline tree
first_call_expr_arg (tree exp, call_expr_arg_iterator *iter)
{
init_call_expr_arg_iterator (exp, iter);
return next_call_expr_arg (iter);
}
static inline const_tree
first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter)
{
init_const_call_expr_arg_iterator (exp, iter);
return next_const_call_expr_arg (iter);
}
static inline bool
more_call_expr_args_p (const call_expr_arg_iterator *iter)
{
return (iter->i < iter->n);
}
# 5525 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
static inline bool
is_lang_specific (const_tree t)
{
return ((enum tree_code) (t)->base.code) == LANG_TYPE || ((enum tree_code) (t)->base.code) >= ((int) LAST_AND_UNUSED_TREE_CODE);
}
static inline tree
builtin_decl_explicit (enum built_in_function fncode)
{
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5539, __FUNCTION__), 0 : 0));
return builtin_info[(size_t)fncode].decl;
}
static inline tree
builtin_decl_implicit (enum built_in_function fncode)
{
size_t uns_fncode = (size_t)fncode;
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5549, __FUNCTION__), 0 : 0));
if (!builtin_info[uns_fncode].implicit_p)
return (tree) nullptr;
return builtin_info[uns_fncode].decl;
}
static inline void
set_builtin_decl (enum built_in_function fncode, tree decl, bool implicit_p)
{
size_t ufncode = (size_t)fncode;
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1))) && (decl != (tree) nullptr || !implicit_p)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5565, __FUNCTION__), 0 : 0))
;
builtin_info[ufncode].decl = decl;
builtin_info[ufncode].implicit_p = implicit_p;
builtin_info[ufncode].declared_p = false;
}
static inline void
set_builtin_decl_implicit_p (enum built_in_function fncode, bool implicit_p)
{
size_t uns_fncode = (size_t)fncode;
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1))) && builtin_info[uns_fncode].decl != (tree) nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5580, __FUNCTION__), 0 : 0))
;
builtin_info[uns_fncode].implicit_p = implicit_p;
}
static inline void
set_builtin_decl_declared_p (enum built_in_function fncode, bool declared_p)
{
size_t uns_fncode = (size_t)fncode;
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1))) && builtin_info[uns_fncode].decl != (tree) nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5593, __FUNCTION__), 0 : 0))
;
builtin_info[uns_fncode].declared_p = declared_p;
}
static inline bool
builtin_decl_explicit_p (enum built_in_function fncode)
{
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5605, __FUNCTION__), 0 : 0));
return (builtin_info[(size_t)fncode].decl != (tree) nullptr);
}
static inline bool
builtin_decl_implicit_p (enum built_in_function fncode)
{
size_t uns_fncode = (size_t)fncode;
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5616, __FUNCTION__), 0 : 0));
return (builtin_info[uns_fncode].decl != (tree) nullptr
&& builtin_info[uns_fncode].implicit_p);
}
static inline bool
builtin_decl_declared_p (enum built_in_function fncode)
{
size_t uns_fncode = (size_t)fncode;
((void)(!((((unsigned long) ((int)fncode) - (unsigned long) (((int)BUILT_IN_NONE) + 1) <= (unsigned long) (((int) END_BUILTINS) - 1) - (unsigned long) (((int)BUILT_IN_NONE) + 1)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5628, __FUNCTION__), 0 : 0));
return (builtin_info[uns_fncode].decl != (tree) nullptr
&& builtin_info[uns_fncode].declared_p);
}
# 5643 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
static inline bool
maybe_special_function_p (const_tree fndecl)
{
tree name_decl = ((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5646, __FUNCTION__))->decl_minimal.name);
if (name_decl
&& (((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5651, __FUNCTION__))->decl_minimal.context) == (tree) nullptr
|| ((enum tree_code) (((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5652, __FUNCTION__))->decl_minimal.context))->base.code) == TRANSLATION_UNIT_DECL)
&& ((fndecl)->base.public_flag))
return true;
return false;
}
static inline bool
is_global_var (const_tree t)
{
return (((t)->base.static_flag) || ((contains_struct_check ((t), (TS_DECL_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5664, __FUNCTION__))->decl_common.decl_flag_1));
}
static inline bool
may_be_aliased (const_tree var)
{
return (((enum tree_code) (var)->base.code) != CONST_DECL
&& (((var)->base.public_flag)
|| ((contains_struct_check ((var), (TS_DECL_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5676, __FUNCTION__))->decl_common.decl_flag_1)
|| ((var)->base.addressable_flag))
&& !((((var)->base.static_flag) || ((var)->base.public_flag) || ((contains_struct_check ((var), (TS_DECL_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5678, __FUNCTION__))->decl_common.decl_flag_1))
&& (((non_type_check ((var), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5679, __FUNCTION__))->base.readonly_flag)
|| (((enum tree_code) (var)->base.code) == VAR_DECL
&& ((tree_check ((var), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5681, __FUNCTION__, (VAR_DECL)))->base.nothrow_flag)))));
}
static inline struct cl_optimization *
opts_for_fn (const_tree fndecl)
{
tree fn_opts = ((tree_check ((fndecl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5688, __FUNCTION__, (FUNCTION_DECL)))->function_decl.function_specific_optimization);
if (fn_opts == (tree) nullptr)
fn_opts = global_trees[TI_OPTIMIZATION_DEFAULT];
return ((tree_check ((fn_opts), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5691, __FUNCTION__, (OPTIMIZATION_NODE)))->optimization.opts);
}
static inline cl_target_option *
target_opts_for_fn (const_tree fndecl)
{
tree fn_opts = ((tree_check ((fndecl), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5698, __FUNCTION__, (FUNCTION_DECL)))->function_decl.function_specific_target);
if (fn_opts == (tree) nullptr)
fn_opts = global_trees[TI_TARGET_OPTION_DEFAULT];
return fn_opts == (tree) nullptr ? nullptr : ((tree_check ((fn_opts), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5701, __FUNCTION__, (TARGET_OPTION_NODE)))->target_option.opts);
}
# 5712 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
extern tree make_anon_name ();
namespace wi
{
class unextended_tree
{
private:
const_tree m_t;
public:
unextended_tree () {}
unextended_tree (const_tree t) : m_t (t) {}
unsigned int get_precision () const;
const long *get_val () const;
unsigned int get_len () const;
const_tree get_tree () const { return m_t; }
};
template <>
struct int_traits <unextended_tree>
{
static const enum precision_type precision_type = VAR_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = false;
};
template <int N>
class extended_tree
{
private:
const_tree m_t;
public:
extended_tree () {}
extended_tree (const_tree);
unsigned int get_precision () const;
const long *get_val () const;
unsigned int get_len () const;
const_tree get_tree () const { return m_t; }
};
template <int N>
struct int_traits <extended_tree <N> >
{
static const enum precision_type precision_type = CONST_PRECISION;
static const bool host_dependent_precision = false;
static const bool is_sign_extended = true;
static const unsigned int precision = N;
};
typedef extended_tree <(((160 + 64) / 64) * 64)> widest_extended_tree;
typedef extended_tree <((64 + 4 + 64 - 1) & ~(64 - 1))> offset_extended_tree;
typedef const generic_wide_int <widest_extended_tree> tree_to_widest_ref;
typedef const generic_wide_int <offset_extended_tree> tree_to_offset_ref;
typedef const generic_wide_int<wide_int_ref_storage<false, false> >
tree_to_wide_ref;
tree_to_widest_ref to_widest (const_tree);
tree_to_offset_ref to_offset (const_tree);
tree_to_wide_ref to_wide (const_tree);
wide_int to_wide (const_tree, unsigned int);
typedef const poly_int <1,
generic_wide_int <widest_extended_tree> >
tree_to_poly_widest_ref;
typedef const poly_int <1,
generic_wide_int <offset_extended_tree> >
tree_to_poly_offset_ref;
typedef const poly_int <1,
generic_wide_int <unextended_tree> >
tree_to_poly_wide_ref;
tree_to_poly_widest_ref to_poly_widest (const_tree);
tree_to_poly_offset_ref to_poly_offset (const_tree);
tree_to_poly_wide_ref to_poly_wide (const_tree);
template <int N>
struct ints_for <generic_wide_int <extended_tree <N> >, CONST_PRECISION>
{
typedef generic_wide_int <extended_tree <N> > extended;
static extended zero (const extended &);
};
template <>
struct ints_for <generic_wide_int <unextended_tree>, VAR_PRECISION>
{
typedef generic_wide_int <unextended_tree> unextended;
static unextended zero (const unextended &);
};
}
typedef generic_wide_int <wi::extended_tree <(((160 + 64) / 64) * 64) * 2> >
widest2_int_cst;
# 5846 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
inline wi::tree_to_widest_ref
wi::to_widest (const_tree t)
{
return t;
}
# 5871 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
inline wi::tree_to_offset_ref
wi::to_offset (const_tree t)
{
return t;
}
# 5901 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
inline wi::tree_to_wide_ref
wi::to_wide (const_tree t)
{
return wi::storage_ref (&(*tree_int_cst_elt_check ((t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5904, __FUNCTION__)), ((tree_check ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5904, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.unextended),
((tree_class_check ((((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5905, __FUNCTION__))->typed.type)), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5905, __FUNCTION__))->type_common.precision));
}
inline wide_int
wi::to_wide (const_tree t, unsigned int prec)
{
return wide_int::from (wi::to_wide (t), prec, ((signop) ((tree_class_check ((((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5915, __FUNCTION__))->typed.type)), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5915, __FUNCTION__))->base.u.bits.unsigned_flag)));
}
template <int N>
inline wi::extended_tree <N>::extended_tree (const_tree t)
: m_t (t)
{
((void)(!(((tree_class_check ((((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5922, __FUNCTION__))->typed.type)), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5922, __FUNCTION__))->type_common.precision) <= N) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5922, __FUNCTION__), 0 : 0));
}
template <int N>
inline unsigned int
wi::extended_tree <N>::get_precision () const
{
return N;
}
template <int N>
inline const long *
wi::extended_tree <N>::get_val () const
{
return &(*tree_int_cst_elt_check ((m_t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5936, __FUNCTION__));
}
template <int N>
inline unsigned int
wi::extended_tree <N>::get_len () const
{
if (N == ((64 + 4 + 64 - 1) & ~(64 - 1)))
return ((tree_check ((m_t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5944, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.offset);
else if (N >= (((160 + 64) / 64) * 64))
return ((tree_check ((m_t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5946, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.extended);
else
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5951, __FUNCTION__));
}
inline unsigned int
wi::unextended_tree::get_precision () const
{
return ((tree_class_check ((((contains_struct_check ((m_t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5957, __FUNCTION__))->typed.type)), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5957, __FUNCTION__))->type_common.precision);
}
inline const long *
wi::unextended_tree::get_val () const
{
return &(*tree_int_cst_elt_check ((m_t), (0), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5963, __FUNCTION__));
}
inline unsigned int
wi::unextended_tree::get_len () const
{
return ((tree_check ((m_t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5969, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.unextended);
}
inline wi::tree_to_poly_wide_ref
poly_int_cst_value (const_tree x)
{
poly_int <1, generic_wide_int <wi::unextended_tree> > res;
for (unsigned int i = 0; i < 1; ++i)
res.coeffs[i] = ((tree_check ((x), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5979, __FUNCTION__, (POLY_INT_CST)))->poly_int_cst.coeffs[i]);
return res;
}
inline wi::tree_to_poly_widest_ref
wi::to_poly_widest (const_tree t)
{
if ((1 > 1 && ((enum tree_code) (t)->base.code) == POLY_INT_CST))
{
poly_int <1,
generic_wide_int <widest_extended_tree> > res;
for (unsigned int i = 0; i < 1; ++i)
res.coeffs[i] = ((tree_check ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 5994, __FUNCTION__, (POLY_INT_CST)))->poly_int_cst.coeffs[i]);
return res;
}
return t;
}
inline wi::tree_to_poly_offset_ref
wi::to_poly_offset (const_tree t)
{
if ((1 > 1 && ((enum tree_code) (t)->base.code) == POLY_INT_CST))
{
poly_int <1,
generic_wide_int <offset_extended_tree> > res;
for (unsigned int i = 0; i < 1; ++i)
res.coeffs[i] = ((tree_check ((t), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6011, __FUNCTION__, (POLY_INT_CST)))->poly_int_cst.coeffs[i]);
return res;
}
return t;
}
inline wi::tree_to_poly_wide_ref
wi::to_poly_wide (const_tree t)
{
if ((1 > 1 && ((enum tree_code) (t)->base.code) == POLY_INT_CST))
return poly_int_cst_value (t);
return t;
}
template <int N>
inline generic_wide_int <wi::extended_tree <N> >
wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
wi::CONST_PRECISION>::zero (const extended &x)
{
return build_zero_cst (((contains_struct_check ((x.get_tree ()), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6033, __FUNCTION__))->typed.type));
}
inline generic_wide_int <wi::unextended_tree>
wi::ints_for <generic_wide_int <wi::unextended_tree>,
wi::VAR_PRECISION>::zero (const unextended &x)
{
return build_zero_cst (((contains_struct_check ((x.get_tree ()), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6040, __FUNCTION__))->typed.type));
}
namespace wi
{
template <typename T>
bool fits_to_boolean_p (const T &x, const_tree);
template <typename T>
bool fits_to_tree_p (const T &x, const_tree);
wide_int min_value (const_tree);
wide_int max_value (const_tree);
wide_int from_mpz (const_tree, mpz_t, bool);
}
template <typename T>
bool
wi::fits_to_boolean_p (const T &x, const_tree type)
{
typedef typename poly_int_traits<T>::int_type int_type;
return ((!maybe_ne (x, int_type (0)))
|| (!maybe_ne (x, int_type (((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6062, __FUNCTION__))->base.u.bits.unsigned_flag) ? 1 : -1))));
}
template <typename T>
bool
wi::fits_to_tree_p (const T &x, const_tree type)
{
if (((enum tree_code) (type)->base.code) == BOOLEAN_TYPE)
return fits_to_boolean_p (x, type);
if (((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6074, __FUNCTION__))->base.u.bits.unsigned_flag))
return (!maybe_ne (x, zext (x, ((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6075, __FUNCTION__))->type_common.precision))));
else
return (!maybe_ne (x, sext (x, ((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6077, __FUNCTION__))->type_common.precision))));
}
inline wide_int
wi::min_value (const_tree type)
{
return min_value (((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6085, __FUNCTION__))->type_common.precision), ((signop) ((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6085, __FUNCTION__))->base.u.bits.unsigned_flag)));
}
inline wide_int
wi::max_value (const_tree type)
{
return max_value (((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6093, __FUNCTION__))->type_common.precision), ((signop) ((tree_class_check ((type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6093, __FUNCTION__))->base.u.bits.unsigned_flag)));
}
inline bool
tree_int_cst_lt (const_tree t1, const_tree t2)
{
return wi::to_widest (t1) < wi::to_widest (t2);
}
inline bool
tree_int_cst_le (const_tree t1, const_tree t2)
{
return wi::to_widest (t1) <= wi::to_widest (t2);
}
inline int
tree_int_cst_compare (const_tree t1, const_tree t2)
{
return wi::cmps (wi::to_widest (t1), wi::to_widest (t2));
}
extern void set_decl_rtl (tree, rtx);
extern bool complete_ctor_at_level_p (const_tree, long, const_tree);
extern tree get_inner_reference (tree, poly_int64_pod *, poly_int64_pod *,
tree *, machine_mode *, int *, int *, int *);
extern tree build_personality_function (const char *);
struct int_n_trees_t {
tree signed_type;
tree unsigned_type;
};
extern bool int_n_enabled_p[1];
extern struct int_n_trees_t int_n_trees[1];
inline long
int_bit_position (const_tree field)
{
return ((wi::to_offset (((tree_check ((field), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6158, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)) << 3)
+ wi::to_offset (((tree_check ((field), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6159, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset))).to_shwi ();
}
inline bool
type_with_alias_set_p (const_tree t)
{
if (((enum tree_code) (t)->base.code) == FUNCTION_TYPE || ((enum tree_code) (t)->base.code) == METHOD_TYPE)
return false;
if ((((tree_class_check ((t), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6171, __FUNCTION__))->type_common.size) != (tree) nullptr))
return true;
if (((enum tree_code) (t)->base.code) == ARRAY_TYPE && (((tree_class_check ((((contains_struct_check ((t), (TS_TYPED), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6176, __FUNCTION__))->typed.type)), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6176, __FUNCTION__))->type_common.size) != (tree) nullptr))
return true;
return false;
}
extern location_t set_block (location_t loc, tree block);
extern void gt_ggc_mx (tree &);
extern void gt_pch_nx (tree &);
extern void gt_pch_nx (tree &, gt_pointer_operator, void *);
extern bool nonnull_arg_p (const_tree);
extern bool default_is_empty_record (const_tree);
extern bool flexible_array_type_p (const_tree);
extern long arg_int_size_in_bytes (const_tree);
extern tree arg_size_in_bytes (const_tree);
extern bool expr_type_first_operand_type_p (tree_code);
extern location_t
set_source_range (tree expr, location_t start, location_t finish);
extern location_t
set_source_range (tree expr, source_range src_range);
inline bool
desired_pro_or_demotion_p (const_tree to_type, const_tree from_type)
{
unsigned int to_type_precision = ((tree_class_check ((to_type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6205, __FUNCTION__))->type_common.precision);
if (to_type_precision <= GET_MODE_PRECISION (word_mode))
return true;
return to_type_precision <= ((tree_class_check ((from_type), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6212, __FUNCTION__))->type_common.precision);
}
class builtin_structptr_type
{
public:
tree& node;
tree& base;
const char *str;
};
extern const builtin_structptr_type builtin_structptr_types[6];
inline bool
type_has_mode_precision_p (const_tree t)
{
return (!maybe_ne (((tree_class_check ((t), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6231, __FUNCTION__))->type_common.precision), GET_MODE_PRECISION (((((enum tree_code) ((tree_class_check ((t), (tcc_type), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6231, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode (t) : (t)->type_common.mode))));
}
inline bool
fndecl_built_in_p (const_tree node)
{
return ((built_in_class) (tree_check ((node), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6243, __FUNCTION__, (FUNCTION_DECL)))->function_decl.built_in_class) != NOT_BUILT_IN;
}
inline bool
fndecl_built_in_p (const_tree node, built_in_class klass)
{
return fndecl_built_in_p (node) && ((built_in_class) (tree_check ((node), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6252, __FUNCTION__, (FUNCTION_DECL)))->function_decl.built_in_class) == klass;
}
inline bool
fndecl_built_in_p (const_tree node, unsigned int name, built_in_class klass)
{
return (fndecl_built_in_p (node, klass)
&& ((tree_check ((node), "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h", 6262, __FUNCTION__, (FUNCTION_DECL)))->function_decl.function_code) == name);
}
inline bool
fndecl_built_in_p (const_tree node, built_in_function name)
{
return (fndecl_built_in_p (node, BUILT_IN_NORMAL)
&& DECL_FUNCTION_CODE (node) == name);
}
# 6304 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree.h"
class op_location_t
{
public:
location_t m_operator_loc;
location_t m_combined_loc;
op_location_t (location_t combined_loc)
: m_operator_loc (((location_t) 0)), m_combined_loc (combined_loc)
{}
op_location_t (location_t operator_loc, location_t combined_loc)
: m_operator_loc (operator_loc), m_combined_loc (combined_loc)
{}
operator location_t () const { return m_combined_loc; }
};
# 100 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfghooks.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfghooks.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/predict.h" 1
# 37 "/home/giulianob/gcc_git_gnu/gcc/gcc/predict.h"
enum br_predictor
{
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/predict.def" 1
# 38 "/home/giulianob/gcc_git_gnu/gcc/gcc/predict.def"
PRED_COMBINED,
PRED_DS_THEORY,
PRED_FIRST_MATCH,
PRED_NO_PREDICTION,
PRED_UNCONDITIONAL,
PRED_MALLOC_NONNULL,
PRED_LOOP_ITERATIONS,
PRED_COMPARE_AND_SWAP,
PRED_BUILTIN_EXPECT,
PRED_BUILTIN_EXPECT_WITH_PROBABILITY,
PRED_HOT_LABEL,
PRED_COLD_LABEL,
PRED_LOOP_ITERATIONS_GUESSED,
PRED_LOOP_ITERATIONS_MAX,
PRED_CONTINUE,
PRED_NORETURN,
PRED_COLD_FUNCTION,
PRED_LOOP_EXIT,
PRED_LOOP_EXIT_WITH_RECURSION,
PRED_LOOP_EXTRA_EXIT,
PRED_POINTER,
PRED_TREE_POINTER,
PRED_OPCODE_POSITIVE,
PRED_OPCODE_NONEQUAL,
PRED_FPOPCODE,
PRED_TREE_OPCODE_POSITIVE,
PRED_TREE_OPCODE_NONEQUAL,
PRED_TREE_FPOPCODE,
PRED_CALL,
PRED_INDIR_CALL,
PRED_POLYMORPHIC_CALL,
PRED_RECURSIVE_CALL,
PRED_TREE_EARLY_RETURN,
PRED_GOTO,
PRED_CONST_RETURN,
PRED_NEGATIVE_RETURN,
PRED_NULL_RETURN,
PRED_LOOP_IV_COMPARE_GUESS,
PRED_LOOP_IV_COMPARE,
# 176 "/home/giulianob/gcc_git_gnu/gcc/gcc/predict.def"
PRED_LOOP_GUARD,
PRED_LOOP_GUARD_WITH_RECURSION,
PRED_FORTRAN_OVERFLOW,
PRED_FORTRAN_FAIL_ALLOC,
PRED_FORTRAN_REALLOC,
PRED_FORTRAN_FAIL_IO,
PRED_FORTRAN_WARN_ONCE,
PRED_FORTRAN_SIZE_ZERO,
PRED_FORTRAN_INVALID_BOUND,
PRED_FORTRAN_ABSENT_DUMMY,
PRED_FORTRAN_LOOP_PREHEADER,
PRED_FORTRAN_CONTIGUOUS,
# 40 "/home/giulianob/gcc_git_gnu/gcc/gcc/predict.h" 2
END_PREDICTORS
};
enum prediction
{
NOT_TAKEN,
TAKEN
};
extern profile_probability split_branch_probability;
extern gcov_type get_hot_bb_threshold (void);
extern void set_hot_bb_threshold (gcov_type);
extern bool maybe_hot_count_p (struct function *, profile_count);
extern bool maybe_hot_bb_p (struct function *, const_basic_block);
extern bool maybe_hot_edge_p (edge);
extern bool probably_never_executed_bb_p (struct function *, const_basic_block);
extern bool probably_never_executed_edge_p (struct function *, edge);
extern bool optimize_function_for_size_p (struct function *);
extern bool optimize_function_for_speed_p (struct function *);
extern optimization_type function_optimization_type (struct function *);
extern bool optimize_bb_for_size_p (const_basic_block);
extern bool optimize_bb_for_speed_p (const_basic_block);
extern optimization_type bb_optimization_type (const_basic_block);
extern bool optimize_edge_for_size_p (edge);
extern bool optimize_edge_for_speed_p (edge);
extern bool optimize_insn_for_size_p (void);
extern bool optimize_insn_for_speed_p (void);
extern bool optimize_loop_for_size_p (class loop *);
extern bool optimize_loop_for_speed_p (class loop *);
extern bool optimize_loop_nest_for_speed_p (class loop *);
extern bool optimize_loop_nest_for_size_p (class loop *);
extern bool predictable_edge_p (edge);
extern void rtl_profile_for_bb (basic_block);
extern void rtl_profile_for_edge (edge);
extern void default_rtl_profile (void);
extern bool rtl_predicted_by_p (const_basic_block, enum br_predictor);
extern bool gimple_predicted_by_p (const_basic_block, enum br_predictor);
extern bool edge_probability_reliable_p (const_edge);
extern bool br_prob_note_reliable_p (const_rtx);
extern void predict_insn_def (rtx_insn *, enum br_predictor, enum prediction);
extern void rtl_predict_edge (edge, enum br_predictor, int);
extern void gimple_predict_edge (edge, enum br_predictor, int);
extern void remove_predictions_associated_with_edge (edge);
extern void predict_edge_def (edge, enum br_predictor, enum prediction);
extern void invert_br_probabilities (rtx);
extern void guess_outgoing_edge_probabilities (basic_block);
extern void tree_guess_outgoing_edge_probabilities (basic_block);
extern void tree_estimate_probability (bool);
extern void handle_missing_profiles (void);
extern bool update_max_bb_count (void);
extern bool expensive_function_p (int);
extern void estimate_bb_frequencies (bool);
extern void compute_function_frequency (void);
extern tree build_predict_expr (enum br_predictor, enum prediction);
extern const char *predictor_name (enum br_predictor);
extern void rebuild_frequencies (void);
extern void report_predictor_hitrates (void);
extern void force_edge_cold (edge, bool);
extern void propagate_unlikely_bbs_forward (void);
extern void add_reg_br_prob_note (rtx_insn *, profile_probability);
extern void warn_function_cold (tree);
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfghooks.h" 2
# 37 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfghooks.h"
struct profile_record
{
int num_mismatched_freq_in;
int num_mismatched_freq_out;
int num_mismatched_count_in;
int num_mismatched_count_out;
gcov_type_unsigned time;
int size;
bool run;
};
typedef int_hash <unsigned short, 0> dependence_hash;
class copy_bb_data
{
public:
copy_bb_data() : dependence_map (nullptr) {}
~copy_bb_data () { delete dependence_map; }
hash_map<dependence_hash, unsigned short> *dependence_map;
};
struct cfg_hooks
{
const char *name;
int (*verify_flow_info) (void);
void (*dump_bb) (FILE *, basic_block, int, dump_flags_t);
void (*dump_bb_for_graph) (pretty_printer *, basic_block);
basic_block (*create_basic_block) (void *head, void *end, basic_block after);
edge (*redirect_edge_and_branch) (edge e, basic_block b);
basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
bool (*can_remove_branch_p) (const_edge);
void (*delete_basic_block) (basic_block);
basic_block (*split_block) (basic_block b, void * i);
bool (*move_block_after) (basic_block b, basic_block a);
bool (*can_merge_blocks_p) (basic_block a, basic_block b);
void (*merge_blocks) (basic_block a, basic_block b);
void (*predict_edge) (edge e, enum br_predictor predictor, int probability);
bool (*predicted_by_p) (const_basic_block bb, enum br_predictor predictor);
bool (*can_duplicate_block_p) (const_basic_block a);
basic_block (*duplicate_block) (basic_block a, copy_bb_data *);
basic_block (*split_edge) (edge);
void (*make_forwarder_block) (edge);
void (*tidy_fallthru_edge) (edge);
basic_block (*force_nonfallthru) (edge);
bool (*block_ends_with_call_p) (basic_block);
bool (*block_ends_with_condjump_p) (const_basic_block);
# 157 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfghooks.h"
int (*flow_call_edges_add) (sbitmap);
void (*execute_on_growing_pred) (edge);
void (*execute_on_shrinking_pred) (edge);
bool (*cfg_hook_duplicate_loop_to_header_edge) (class loop *, edge,
unsigned, sbitmap,
edge, vec<edge> *,
int);
void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block,
void *);
void (*lv_adjust_loop_header_phi) (basic_block, basic_block,
basic_block, edge);
void (*extract_cond_bb_edges) (basic_block, edge *, edge *);
void (*flush_pending_stmts) (edge);
bool (*empty_block_p) (basic_block);
basic_block (*split_block_before_cond_jump) (basic_block);
void (*account_profile_record) (basic_block, struct profile_record *);
};
extern void verify_flow_info (void);
static inline void
checking_verify_flow_info (void)
{
if (global_options.x_flag_checking)
verify_flow_info ();
}
extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
extern void dump_bb_for_graph (pretty_printer *, basic_block);
extern void dump_flow_info (FILE *, dump_flags_t);
extern edge redirect_edge_and_branch (edge, basic_block);
extern basic_block redirect_edge_and_branch_force (edge, basic_block);
extern edge redirect_edge_succ_nodup (edge, basic_block);
extern bool can_remove_branch_p (const_edge);
extern void remove_branch (edge);
extern void remove_edge (edge);
extern edge split_block (basic_block, rtx);
extern edge split_block (basic_block, gimple *);
extern edge split_block_after_labels (basic_block);
extern bool move_block_after (basic_block, basic_block);
extern void delete_basic_block (basic_block);
extern basic_block split_edge (edge);
extern basic_block create_basic_block (rtx, rtx, basic_block);
extern basic_block create_basic_block (gimple_seq, basic_block);
extern basic_block create_empty_bb (basic_block);
extern bool can_merge_blocks_p (basic_block, basic_block);
extern void merge_blocks (basic_block, basic_block);
extern edge make_forwarder_block (basic_block, bool (*)(edge),
void (*) (basic_block));
extern basic_block force_nonfallthru (edge);
extern void tidy_fallthru_edge (edge);
extern void tidy_fallthru_edges (void);
extern void predict_edge (edge e, enum br_predictor predictor, int probability);
extern bool predicted_by_p (const_basic_block bb, enum br_predictor predictor);
extern bool can_duplicate_block_p (const_basic_block);
extern basic_block duplicate_block (basic_block, edge, basic_block,
copy_bb_data * = nullptr);
extern bool block_ends_with_call_p (basic_block bb);
extern bool empty_block_p (basic_block);
extern basic_block split_block_before_cond_jump (basic_block);
extern bool block_ends_with_condjump_p (const_basic_block bb);
extern int flow_call_edges_add (sbitmap);
extern void execute_on_growing_pred (edge);
extern void execute_on_shrinking_pred (edge);
extern bool cfg_hook_duplicate_loop_to_header_edge (class loop *loop, edge,
unsigned int ndupl,
sbitmap wont_exit,
edge orig,
vec<edge> *to_remove,
int flags);
extern void lv_flush_pending_stmts (edge);
extern void extract_cond_bb_edges (basic_block, edge *, edge*);
extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block,
edge);
extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block,
void *);
extern bool can_copy_bbs_p (basic_block *, unsigned);
extern void copy_bbs (basic_block *, unsigned, basic_block *,
edge *, unsigned, edge *, class loop *,
basic_block, bool);
void profile_record_check_consistency (profile_record *);
void profile_record_account_profile (profile_record *);
extern struct cfg_hooks gimple_cfg_hooks;
extern struct cfg_hooks rtl_cfg_hooks;
extern struct cfg_hooks cfg_layout_rtl_cfg_hooks;
extern enum ir_type current_ir_type (void);
extern void rtl_register_cfg_hooks (void);
extern void cfg_layout_rtl_register_cfg_hooks (void);
extern void gimple_register_cfg_hooks (void);
extern struct cfg_hooks get_cfg_hooks (void);
extern void set_cfg_hooks (struct cfg_hooks);
# 101 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/regset.h" 1
# 35 "/home/giulianob/gcc_git_gnu/gcc/gcc/regset.h"
typedef bitmap_head regset_head;
typedef bitmap regset;
# 88 "/home/giulianob/gcc_git_gnu/gcc/gcc/regset.h"
extern void reg_set_to_hard_reg_set (HARD_REG_SET *, const_bitmap);
typedef bitmap_iterator reg_set_iterator;
# 115 "/home/giulianob/gcc_git_gnu/gcc/gcc/regset.h"
extern bitmap_obstack reg_obstack;
extern void dump_regset (regset, FILE *);
# 29 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
# 1 "./options.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 2
extern void dump_alloc_pool_statistics (void);
extern bool after_memory_report;
typedef unsigned long ALLOC_POOL_ID_TYPE;
extern ALLOC_POOL_ID_TYPE last_id;
class pool_usage: public mem_usage
{
public:
pool_usage (): m_element_size (0), m_pool_name ("") {}
pool_usage (size_t allocated, size_t times, size_t peak,
size_t instances, size_t element_size,
const char *pool_name)
: mem_usage (allocated, times, peak, instances),
m_element_size (element_size),
m_pool_name (pool_name) {}
pool_usage
operator+ (const pool_usage &second)
{
return pool_usage (m_allocated + second.m_allocated,
m_times + second.m_times,
m_peak + second.m_peak,
m_instances + second.m_instances,
m_element_size, m_pool_name);
}
inline void
dump (mem_location *loc, const mem_usage &total) const
{
char *location_string = loc->to_string ();
fprintf (
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
stderr
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
, "%-32s%-48s " "%" "5"
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"%c" "%" "9"
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 67 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"%c" ":%5.1f%%"
"%" "9"
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"%c" "%" "9"
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"%c" ":%5.1f%%%12"
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"\n",
m_pool_name, location_string,
(uint64_t)(((m_instances) < 10 * 1024 ? (m_instances) : ((m_instances) < 10 * (1024 * 1024) ? (m_instances) / 1024 : (m_instances) / (1024 * 1024)))), ((m_instances) < 10 * 1024 ? ' ' : ((m_instances) < 10 * (1024 * 1024) ? 'k' : 'M')),
(uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_allocated, total.m_allocated),
(uint64_t)(((m_peak) < 10 * 1024 ? (m_peak) : ((m_peak) < 10 * (1024 * 1024) ? (m_peak) / 1024 : (m_peak) / (1024 * 1024)))), ((m_peak) < 10 * 1024 ? ' ' : ((m_peak) < 10 * (1024 * 1024) ? 'k' : 'M')),
(uint64_t)(((m_times) < 10 * 1024 ? (m_times) : ((m_times) < 10 * (1024 * 1024) ? (m_times) / 1024 : (m_times) / (1024 * 1024)))), ((m_times) < 10 * 1024 ? ' ' : ((m_times) < 10 * (1024 * 1024) ? 'k' : 'M')),
get_percent (m_times, total.m_times),
(uint64_t)m_element_size);
free (location_string);
}
static inline void
dump_header (const char *name)
{
fprintf (
# 85 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
stderr
# 85 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
, "%-32s%-48s %6s%11s%16s%17s%12s\n", "Pool name", name,
"Pools", "Leak", "Peak", "Times", "Elt size");
}
inline void
dump_footer ()
{
fprintf (
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
stderr
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
, "%s" "%" "82"
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"%c" "%" "10"
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
"l" "u"
# 93 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
"%c" "\n", "Total",
(uint64_t)(((m_instances) < 10 * 1024 ? (m_instances) : ((m_instances) < 10 * (1024 * 1024) ? (m_instances) / 1024 : (m_instances) / (1024 * 1024)))), ((m_instances) < 10 * 1024 ? ' ' : ((m_instances) < 10 * (1024 * 1024) ? 'k' : 'M')), (uint64_t)(((m_allocated) < 10 * 1024 ? (m_allocated) : ((m_allocated) < 10 * (1024 * 1024) ? (m_allocated) / 1024 : (m_allocated) / (1024 * 1024)))), ((m_allocated) < 10 * 1024 ? ' ' : ((m_allocated) < 10 * (1024 * 1024) ? 'k' : 'M')));
}
size_t m_element_size;
const char *m_pool_name;
};
extern mem_alloc_description<pool_usage> pool_allocator_usage;
# 140 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
template <typename TBlockAllocator>
class base_pool_allocator
{
public:
base_pool_allocator (const char *name, size_t size );
~base_pool_allocator ();
void release ();
void release_if_empty ();
void *allocate () __attribute__ ((__malloc__));
void remove (void *object);
size_t num_elts_current ();
private:
struct allocation_pool_list
{
allocation_pool_list *next;
};
void initialize ();
struct allocation_object
{
ALLOC_POOL_ID_TYPE id;
union
{
char data[1];
char *align_p;
int64_t align_i;
} u;
static inline allocation_object*
get_instance (void *data_ptr)
{
return (allocation_object *)(((char *)(data_ptr))
-
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
__builtin_offsetof (
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
allocation_object
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
,
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
u.data
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
)
# 188 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
);
}
static inline void*
get_data (void *instance_ptr)
{
return (void*)(((allocation_object *) instance_ptr)->u.data);
}
};
static inline size_t
align_eight (size_t x)
{
return (((x+7) >> 3) << 3);
}
const char *m_name;
ALLOC_POOL_ID_TYPE m_id;
size_t m_elts_per_block;
allocation_pool_list *m_returned_free_list;
char* m_virgin_free_list;
size_t m_virgin_elts_remaining;
size_t m_elts_allocated;
size_t m_elts_free;
size_t m_blocks_allocated;
allocation_pool_list *m_block_list;
size_t m_elt_size;
size_t m_size;
bool m_initialized;
mem_location m_location;
};
template <typename TBlockAllocator>
inline
base_pool_allocator <TBlockAllocator>::base_pool_allocator (
const char *name, size_t size ):
m_name (name), m_id (0), m_elts_per_block (0), m_returned_free_list (nullptr),
m_virgin_free_list (nullptr), m_virgin_elts_remaining (0), m_elts_allocated (0),
m_elts_free (0), m_blocks_allocated (0), m_block_list (nullptr), m_elt_size (0),
m_size (size), m_initialized (false),
m_location (ALLOC_POOL_ORIGIN, false ) {}
template <typename TBlockAllocator>
inline void
base_pool_allocator <TBlockAllocator>::initialize ()
{
((void)(!(!m_initialized) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 255, __FUNCTION__), 0 : 0));
m_initialized = true;
size_t size = m_size;
((void)(!(m_name) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 260, __FUNCTION__), 0 : 0));
((void)(!(m_size) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 261, __FUNCTION__), 0 : 0));
if (size < sizeof (allocation_pool_list*))
size = sizeof (allocation_pool_list*);
size = align_eight (size);
size +=
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
__builtin_offsetof (
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
allocation_object
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
,
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
u.data
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
)
# 271 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
;
m_elt_size = size;
if (0)
{
pool_usage *u = pool_allocator_usage.register_descriptor
(this, new mem_location (m_location));
u->m_element_size = m_elt_size;
u->m_pool_name = m_name;
}
size_t header_size = align_eight (sizeof (allocation_pool_list));
m_elts_per_block = (TBlockAllocator::block_size - header_size) / size;
((void)(!(m_elts_per_block != 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 288, __FUNCTION__), 0 : 0));
last_id++;
if (last_id == 0)
last_id++;
m_id = last_id;
}
template <typename TBlockAllocator>
inline void
base_pool_allocator <TBlockAllocator>::release ()
{
if (!m_initialized)
return;
allocation_pool_list *block, *next_block;
for (block = m_block_list; block != nullptr; block = next_block)
{
next_block = block->next;
TBlockAllocator::release (block);
}
if (0 && !after_memory_report)
{
pool_allocator_usage.release_instance_overhead
(this, (m_elts_allocated - m_elts_free) * m_elt_size);
}
m_returned_free_list = nullptr;
m_virgin_free_list = nullptr;
m_virgin_elts_remaining = 0;
m_elts_allocated = 0;
m_elts_free = 0;
m_blocks_allocated = 0;
m_block_list = nullptr;
}
template <typename TBlockAllocator>
inline void
base_pool_allocator <TBlockAllocator>::release_if_empty ()
{
if (m_elts_free == m_elts_allocated)
release ();
}
template <typename TBlockAllocator>
inline base_pool_allocator <TBlockAllocator>::~base_pool_allocator ()
{
release ();
}
template <typename TBlockAllocator>
inline void*
base_pool_allocator <TBlockAllocator>::allocate ()
{
if (!m_initialized)
initialize ();
allocation_pool_list *header;
if (0)
{
pool_allocator_usage.register_instance_overhead (m_elt_size, this);
}
if (!m_returned_free_list)
{
char *block;
if (!m_virgin_elts_remaining)
{
allocation_pool_list *block_header;
block = reinterpret_cast<char *> (TBlockAllocator::allocate ());
block_header = new (block) allocation_pool_list;
block += align_eight (sizeof (allocation_pool_list));
block_header->next = m_block_list;
m_block_list = block_header;
m_virgin_free_list = block;
m_virgin_elts_remaining = m_elts_per_block;
m_elts_allocated += m_elts_per_block;
m_elts_free += m_elts_per_block;
m_blocks_allocated += 1;
}
block = m_virgin_free_list;
header = (allocation_pool_list*) allocation_object::get_data (block);
header->next = nullptr;
((allocation_object*) block)->id = 0;
;
m_returned_free_list = header;
m_virgin_free_list += m_elt_size;
m_virgin_elts_remaining--;
}
header = m_returned_free_list;
;
m_returned_free_list = header->next;
m_elts_free--;
allocation_object::get_instance (header)->id = m_id;
;
return (void *)(header);
}
template <typename TBlockAllocator>
inline void
base_pool_allocator <TBlockAllocator>::remove (void *object)
{
int size = m_elt_size -
# 432 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
__builtin_offsetof (
# 432 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
allocation_object
# 432 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
,
# 432 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
u.data
# 432 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h" 3 4
)
# 432 "/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h"
;
if (global_options.x_flag_checking)
{
((void)(!(m_initialized) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 436, __FUNCTION__), 0 : 0));
((void)(!(object && m_elts_free < m_elts_allocated) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 437, __FUNCTION__), 0 : 0))
;
((void)(!(m_id == allocation_object::get_instance (object)->id) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/alloc-pool.h", 442, __FUNCTION__), 0 : 0));
memset (object, 0xaf, size);
}
allocation_object::get_instance (object)->id = 0;
allocation_pool_list *header = new (object) allocation_pool_list;
header->next = m_returned_free_list;
m_returned_free_list = header;
;
m_elts_free++;
if (0)
{
pool_allocator_usage.release_instance_overhead (this, m_elt_size);
}
}
template <typename TBlockAllocator>
inline size_t
base_pool_allocator <TBlockAllocator>::num_elts_current ()
{
return m_elts_allocated - m_elts_free;
}
typedef base_pool_allocator <memory_block_pool> pool_allocator;
template <typename T>
class object_allocator
{
public:
object_allocator (const char *name ):
m_allocator (name, sizeof (T) ) {}
inline void
release ()
{
m_allocator.release ();
}
inline void release_if_empty ()
{
m_allocator.release_if_empty ();
}
inline T *
allocate () __attribute__ ((__malloc__))
{
return ::new (m_allocator.allocate ()) T;
}
inline void *
allocate_raw () __attribute__ ((__malloc__))
{
return m_allocator.allocate ();
}
inline void
remove (T *object)
{
object->~T ();
m_allocator.remove (object);
}
inline void
remove_raw (void *object)
{
m_allocator.remove (object);
}
inline size_t
num_elts_current ()
{
return m_allocator.num_elts_current ();
}
private:
pool_allocator m_allocator;
};
struct alloc_pool_descriptor
{
unsigned long created;
unsigned long allocated;
unsigned long current;
unsigned long peak;
int elt_size;
};
template <typename T>
inline void *
operator new (size_t, object_allocator<T> &a)
{
return a.allocate_raw ();
}
extern hash_map<const char *, alloc_pool_descriptor> *alloc_pool_hash;
# 30 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/timevar.h" 1
# 52 "/home/giulianob/gcc_git_gnu/gcc/gcc/timevar.h"
struct timevar_time_def
{
double user;
double sys;
double wall;
size_t ggc_mem;
};
typedef enum
{
TV_NONE,
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/timevar.def" 1
# 33 "/home/giulianob/gcc_git_gnu/gcc/gcc/timevar.def"
TV_TOTAL,
TV_PHASE_SETUP,
TV_PHASE_PARSING,
TV_PHASE_DEFERRED,
TV_PHASE_LATE_PARSING_CLEANUPS,
TV_PHASE_OPT_GEN,
TV_PHASE_LATE_ASM,
TV_PHASE_STREAM_IN,
TV_PHASE_STREAM_OUT,
TV_PHASE_FINALIZE,
TV_NAME_LOOKUP,
TV_OVERLOAD,
TV_GC,
TV_DUMP,
TV_PCH_SAVE,
TV_PCH_CPP_SAVE,
TV_PCH_PTR_REALLOC,
TV_PCH_PTR_SORT,
TV_PCH_RESTORE,
TV_PCH_CPP_RESTORE,
TV_CGRAPH,
TV_CGRAPHOPT,
TV_CGRAPH_FUNC_EXPANSION,
TV_CGRAPH_IPA_PASSES,
TV_IPA_ODR,
TV_IPA_FNSUMMARY,
TV_IPA_UNREACHABLE,
TV_IPA_INHERITANCE,
TV_IPA_VIRTUAL_CALL,
TV_IPA_DEVIRT,
TV_IPA_CONSTANT_PROP,
TV_IPA_INLINING,
TV_IPA_FNSPLIT,
TV_IPA_COMDATS,
TV_IPA_OPT,
TV_IPA_LTO_DECOMPRESS,
TV_IPA_LTO_COMPRESS,
TV_IPA_LTO_OUTPUT,
TV_IPA_LTO_GIMPLE_IN,
TV_IPA_LTO_GIMPLE_OUT,
TV_IPA_LTO_DECL_IN,
TV_IPA_LTO_DECL_OUT,
TV_IPA_LTO_CTORS_IN,
TV_IPA_LTO_CTORS_OUT,
TV_IPA_LTO_CGRAPH_IO,
TV_IPA_LTO_DECL_MERGE,
TV_IPA_LTO_CGRAPH_MERGE,
TV_LTO,
TV_WHOPR_WPA,
TV_WHOPR_WPA_IO,
TV_WHOPR_PARTITIONING,
TV_WHOPR_LTRANS,
TV_IPA_REFERENCE,
TV_IPA_PROFILE,
TV_IPA_AUTOFDO,
TV_IPA_PURE_CONST,
TV_IPA_ICF,
TV_IPA_PTA,
TV_IPA_SRA,
TV_IPA_FREE_LANG_DATA,
TV_IPA_FREE_INLINE_SUMMARY,
TV_CFG,
TV_CLEANUP_CFG,
TV_CFG_VERIFY,
TV_DELETE_TRIVIALLY_DEAD,
TV_DF_SCAN,
TV_DF_MD,
TV_DF_RD,
TV_DF_LR,
TV_DF_LIVE,
TV_DF_MIR,
TV_DF_CHAIN,
TV_DF_WORD_LR,
TV_DF_NOTE,
TV_REG_STATS,
TV_ALIAS_ANALYSIS,
TV_ALIAS_STMT_WALK,
TV_REG_SCAN,
TV_REBUILD_JUMP,
TV_CPP,
TV_LEX,
TV_PARSE_GLOBAL,
TV_PARSE_STRUCT,
TV_PARSE_ENUM,
TV_PARSE_FUNC,
TV_PARSE_INLINE,
TV_PARSE_INMETH,
TV_TEMPLATE_INST,
TV_CONSTEXPR,
TV_CONSTRAINT_NORM,
TV_CONSTRAINT_SAT,
TV_CONSTRAINT_SUB,
TV_FLATTEN_INLINING,
TV_EARLY_INLINING,
TV_INLINE_PARAMETERS,
TV_INTEGRATION,
TV_TREE_GIMPLIFY,
TV_TREE_EH,
TV_TREE_CFG,
TV_TREE_CLEANUP_CFG,
TV_TREE_TAIL_MERGE,
TV_TREE_VRP,
TV_TREE_EARLY_VRP,
TV_TREE_COPY_PROP,
TV_FIND_REFERENCED_VARS,
TV_TREE_PTA,
TV_TREE_INSERT_PHI_NODES,
TV_TREE_SSA_REWRITE_BLOCKS,
TV_TREE_SSA_OTHER,
TV_TREE_SSA_INCREMENTAL,
TV_TREE_OPS,
TV_TREE_SSA_DOMINATOR_OPTS,
TV_TREE_SSA_THREAD_JUMPS,
TV_TREE_SRA,
TV_ISOLATE_ERRONEOUS_PATHS,
TV_TREE_CCP,
TV_TREE_SPLIT_EDGES,
TV_TREE_REASSOC,
TV_TREE_PRE,
TV_TREE_FRE,
TV_TREE_SINK,
TV_TREE_PHIOPT,
TV_TREE_BACKPROP,
TV_TREE_FORWPROP,
TV_TREE_PHIPROP,
TV_TREE_DCE,
TV_TREE_CD_DCE,
TV_TREE_CALL_CDCE,
TV_TREE_DSE,
TV_TREE_MERGE_PHI,
TV_TREE_LOOP,
TV_TREE_NOLOOP,
TV_TREE_LOOP_BOUNDS,
TV_LIM,
TV_LINTERCHANGE,
TV_TREE_LOOP_IVCANON,
TV_SCEV_CONST,
TV_TREE_LOOP_UNSWITCH,
TV_LOOP_SPLIT,
TV_LOOP_JAM,
TV_COMPLETE_UNROLL,
TV_TREE_PARALLELIZE_LOOPS,
TV_TREE_VECTORIZATION,
TV_TREE_SLP_VECTORIZATION,
TV_GRAPHITE,
TV_GRAPHITE_TRANSFORMS,
TV_GRAPHITE_DATA_DEPS,
TV_GRAPHITE_CODE_GEN,
TV_TREE_LOOP_DISTRIBUTION,
TV_CHECK_DATA_DEPS,
TV_TREE_PREFETCH,
TV_TREE_LOOP_IVOPTS,
TV_PREDCOM,
TV_TREE_CH,
TV_TREE_SSA_UNCPROP,
TV_TREE_NRV,
TV_TREE_COPY_RENAME,
TV_TREE_SSA_VERIFY,
TV_TREE_STMT_VERIFY,
TV_TREE_SWITCH_CONVERSION,
TV_TREE_SWITCH_LOWERING,
TV_TREE_RECIP,
TV_TREE_SINCOS,
TV_TREE_WIDEN_MUL,
TV_TRANS_MEM,
TV_TREE_STRLEN,
TV_CGRAPH_VERIFY,
TV_DOM_FRONTIERS,
TV_DOMINANCE,
TV_CONTROL_DEPENDENCES,
TV_OUT_OF_SSA,
TV_VAR_EXPAND,
TV_EXPAND,
TV_POST_EXPAND,
TV_VARCONST,
TV_LOWER_SUBREG,
TV_JUMP,
TV_FWPROP,
TV_CSE,
TV_DCE,
TV_DSE1,
TV_DSE2,
TV_LOOP,
TV_LOOP_INIT,
TV_LOOP_VERSIONING,
TV_LOOP_MOVE_INVARIANTS,
TV_LOOP_UNROLL,
TV_LOOP_DOLOOP,
TV_LOOP_FINI,
TV_CPROP,
TV_PRE,
TV_HOIST,
TV_LSM,
TV_TRACER,
TV_WEB,
TV_AUTO_INC_DEC,
TV_CSE2,
TV_BRANCH_PROB,
TV_COMBINE,
TV_IFCVT,
TV_MODE_SWITCH,
TV_SMS,
TV_LIVE_RANGE_SHRINKAGE,
TV_SCHED,
TV_EARLY_REMAT,
TV_IRA,
TV_LRA,
TV_LRA_ELIMINATE,
TV_LRA_INHERITANCE,
TV_LRA_CREATE_LIVE_RANGES,
TV_LRA_ASSIGN,
TV_LRA_COALESCE,
TV_LRA_REMAT,
TV_RELOAD,
TV_RELOAD_CSE_REGS,
TV_GCSE_AFTER_RELOAD,
TV_REE,
TV_THREAD_PROLOGUE_AND_EPILOGUE,
TV_IFCVT2,
TV_SPLIT_PATHS,
TV_COMBINE_STACK_ADJUST,
TV_PEEPHOLE2,
TV_RENAME_REGISTERS,
TV_SCHED_FUSION,
TV_CPROP_REGISTERS,
TV_SCHED2,
TV_MACH_DEP,
TV_DBR_SCHED,
TV_REORDER_BLOCKS,
TV_SHORTEN_BRANCH,
TV_REG_STACK,
TV_FINAL,
TV_VAROUT,
TV_SYMOUT,
TV_VAR_TRACKING,
TV_VAR_TRACKING_DATAFLOW,
TV_VAR_TRACKING_EMIT,
TV_TREE_IFCOMBINE,
TV_TREE_UNINIT,
TV_PLUGIN_INIT,
TV_PLUGIN_RUN,
TV_GIMPLE_SLSR,
TV_GIMPLE_STORE_MERGING,
TV_VTABLE_VERIFICATION,
TV_TREE_UBSAN,
TV_INITIALIZE_RTL,
TV_GIMPLE_LADDRESS,
TV_TREE_LOOP_IFCVT,
TV_EARLY_LOCAL,
TV_OPTIMIZE,
TV_REST_OF_COMPILATION,
TV_POSTRELOAD,
TV_LATE_COMPILATION,
TV_REMOVE_UNUSED,
TV_ADDRESS_TAKEN,
TV_TODO,
TV_VERIFY_LOOP_CLOSED,
TV_VERIFY_RTL_SHARING,
TV_REBUILD_FREQUENCIES,
TV_REPAIR_LOOPS,
TV_JIT_REPLAY,
TV_ASSEMBLE,
TV_LINK,
TV_LOAD,
TV_JIT_ACQUIRING_MUTEX,
TV_JIT_CLIENT_CODE,
TV_ANALYZER,
TV_ANALYZER_SUPERGRAPH,
TV_ANALYZER_STATE_PURGE,
TV_ANALYZER_PLAN,
TV_ANALYZER_SCC,
TV_ANALYZER_WORKLIST,
TV_ANALYZER_DUMP,
TV_ANALYZER_DIAGNOSTICS,
TV_ANALYZER_SHORTEST_PATHS,
# 77 "/home/giulianob/gcc_git_gnu/gcc/gcc/timevar.h" 2
TIMEVAR_LAST
}
timevar_id_t;
class timer;
extern timer *g_timer;
extern size_t timevar_ggc_mem_total;
extern void timevar_init (void);
extern void timevar_start (timevar_id_t);
extern void timevar_stop (timevar_id_t);
extern bool timevar_cond_start (timevar_id_t);
extern void timevar_cond_stop (timevar_id_t, bool);
class timer
{
public:
timer ();
~timer ();
void start (timevar_id_t tv);
void stop (timevar_id_t tv);
void push (timevar_id_t tv);
void pop (timevar_id_t tv);
bool cond_start (timevar_id_t tv);
void cond_stop (timevar_id_t tv);
void push_client_item (const char *item_name);
void pop_client_item ();
void print (FILE *fp);
const char *get_topmost_item_name () const;
private:
void validate_phases (FILE *fp) const;
struct timevar_def;
void push_internal (struct timevar_def *tv);
void pop_internal ();
static void print_row (FILE *fp,
const timevar_time_def *total,
const char *name, const timevar_time_def &elapsed);
static bool all_zero (const timevar_time_def &elapsed);
private:
typedef hash_map<timevar_def *, timevar_time_def> child_map_t;
struct timevar_def
{
struct timevar_time_def elapsed;
struct timevar_time_def start_time;
const char *name;
unsigned standalone : 1;
unsigned used : 1;
child_map_t *children;
};
struct timevar_stack_def
{
struct timevar_def *timevar;
struct timevar_stack_def *next;
};
class named_items;
private:
timevar_def m_timevars[TIMEVAR_LAST];
timevar_stack_def *m_stack;
timevar_stack_def *m_unused_stack_instances;
timevar_time_def m_start_time;
named_items *m_jit_client_items;
friend class named_items;
};
static inline void
timevar_push (timevar_id_t tv)
{
if (g_timer)
g_timer->push (tv);
}
static inline void
timevar_pop (timevar_id_t tv)
{
if (g_timer)
g_timer->pop (tv);
}
class auto_timevar
{
public:
auto_timevar (timer *t, timevar_id_t tv)
: m_timer (t),
m_tv (tv)
{
if (m_timer)
m_timer->push (m_tv);
}
explicit auto_timevar (timevar_id_t tv)
: m_timer (g_timer)
, m_tv (tv)
{
if (m_timer)
m_timer->push (m_tv);
}
~auto_timevar ()
{
if (m_timer)
m_timer->pop (m_tv);
}
private:
auto_timevar (const auto_timevar &);
timer *m_timer;
timevar_id_t m_tv;
};
extern void print_time (const char *, long);
# 31 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h" 2
struct dataflow;
class df_d;
struct df_problem;
struct df_link;
struct df_insn_info;
union df_ref_d;
# 46 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
enum df_problem_id
{
DF_SCAN,
DF_LR,
DF_LIVE,
DF_RD,
DF_CHAIN,
DF_WORD_LR,
DF_NOTE,
DF_MD,
DF_MIR,
DF_LAST_PROBLEM_PLUS1
};
enum df_flow_dir
{
DF_NONE,
DF_FORWARD,
DF_BACKWARD
};
enum df_ref_class {DF_REF_BASE, DF_REF_ARTIFICIAL, DF_REF_REGULAR};
enum df_ref_type {DF_REF_REG_DEF, DF_REF_REG_USE,
DF_REF_REG_MEM_LOAD, DF_REF_REG_MEM_STORE};
enum df_ref_flags
{
DF_REF_CONDITIONAL = 1 << 0,
DF_REF_AT_TOP = 1 << 1,
DF_REF_IN_NOTE = 1 << 2,
DF_HARD_REG_LIVE = 1 << 3,
DF_REF_PARTIAL = 1 << 4,
DF_REF_READ_WRITE = 1 << 5,
DF_REF_MAY_CLOBBER = 1 << 6,
# 124 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
DF_REF_MUST_CLOBBER = 1 << 7,
DF_REF_SIGN_EXTRACT = 1 << 8,
DF_REF_ZERO_EXTRACT = 1 << 9,
DF_REF_STRICT_LOW_PART = 1 << 10,
DF_REF_SUBREG = 1 << 11,
DF_REF_MW_HARDREG = 1 << 12,
DF_REF_CALL_STACK_USAGE = 1 << 13,
DF_REF_REG_MARKER = 1 << 14,
DF_REF_PRE_POST_MODIFY = 1 << 15
};
enum df_ref_order
{
DF_REF_ORDER_NO_TABLE,
DF_REF_ORDER_UNORDERED,
DF_REF_ORDER_UNORDERED_WITH_NOTES,
DF_REF_ORDER_BY_REG,
DF_REF_ORDER_BY_REG_WITH_NOTES,
DF_REF_ORDER_BY_INSN,
DF_REF_ORDER_BY_INSN_WITH_NOTES
};
typedef void (*df_alloc_function) (bitmap);
typedef void (*df_reset_function) (bitmap);
typedef void (*df_free_bb_function) (basic_block, void *);
typedef void (*df_local_compute_function) (bitmap);
typedef void (*df_init_function) (bitmap);
typedef void (*df_dataflow_function) (struct dataflow *, bitmap, int *, int);
typedef void (*df_confluence_function_0) (basic_block);
typedef bool (*df_confluence_function_n) (edge);
typedef bool (*df_transfer_function) (int);
typedef void (*df_finalizer_function) (bitmap);
typedef void (*df_free_function) (void);
typedef void (*df_remove_problem_function) (void);
typedef void (*df_dump_problem_function) (FILE *);
typedef void (*df_dump_bb_problem_function) (basic_block, FILE *);
typedef void (*df_dump_insn_problem_function) (const rtx_insn *, FILE *);
typedef void (*df_verify_solution_start) (void);
typedef void (*df_verify_solution_end) (void);
struct df_problem {
enum df_problem_id id;
enum df_flow_dir dir;
df_alloc_function alloc_fun;
df_reset_function reset_fun;
df_free_bb_function free_bb_fun;
df_local_compute_function local_compute_fun;
df_init_function init_fun;
df_dataflow_function dataflow_fun;
df_confluence_function_0 con_fun_0;
df_confluence_function_n con_fun_n;
df_transfer_function trans_fun;
df_finalizer_function finalize_fun;
df_free_function free_fun;
df_remove_problem_function remove_problem_fun;
df_dump_problem_function dump_start_fun;
df_dump_bb_problem_function dump_top_fun;
df_dump_bb_problem_function dump_bottom_fun;
df_dump_insn_problem_function dump_insn_top_fun;
df_dump_insn_problem_function dump_insn_bottom_fun;
df_verify_solution_start verify_start_fun;
df_verify_solution_end verify_end_fun;
const struct df_problem *dependent_problem;
unsigned int block_info_elt_size;
timevar_id_t tv_id;
bool free_blocks_on_set_blocks;
};
struct dataflow
{
const struct df_problem *problem;
void *block_info;
unsigned int block_info_size;
object_allocator<df_link> *block_pool;
bitmap out_of_date_transfer_functions;
void *problem_data;
unsigned int local_flags;
bool computed;
bool solutions_dirty;
bool optional_p;
};
struct df_mw_hardreg
{
df_mw_hardreg *next;
rtx mw_reg;
enum df_ref_type type : 16;
int flags : 16;
unsigned int start_regno;
unsigned int end_regno;
unsigned int mw_order;
};
struct df_base_ref
{
enum df_ref_class cl : 8;
enum df_ref_type type : 8;
int flags : 16;
unsigned int regno;
rtx reg;
union df_ref_d *next_loc;
struct df_link *chain;
struct df_insn_info *insn_info;
union df_ref_d *next_reg;
union df_ref_d *prev_reg;
int id;
unsigned int ref_order;
};
struct df_artificial_ref
{
struct df_base_ref base;
basic_block bb;
};
struct df_regular_ref
{
struct df_base_ref base;
rtx *loc;
};
union df_ref_d
{
struct df_base_ref base;
struct df_regular_ref regular_ref;
struct df_artificial_ref artificial_ref;
};
typedef union df_ref_d *df_ref;
struct df_insn_info
{
rtx_insn *insn;
df_ref defs;
df_ref uses;
df_ref eq_uses;
struct df_mw_hardreg *mw_hardregs;
int luid;
};
struct df_link
{
df_ref ref;
struct df_link *next;
};
enum df_chain_flags
{
DF_DU_CHAIN = 1,
DF_UD_CHAIN = 2
};
enum df_scan_flags
{
DF_SCAN_EMPTY_ENTRY_EXIT = 1
};
enum df_changeable_flags
{
DF_LR_RUN_DCE = 1 << 0,
DF_NO_HARD_REGS = 1 << 1,
DF_EQ_NOTES = 1 << 2,
DF_NO_REGS_EVER_LIVE = 1 << 3,
DF_NO_INSN_RESCAN = 1 << 4,
DF_DEFER_INSN_RESCAN = 1 << 5,
DF_RD_PRUNE_DEAD_DEFS = 1 << 6,
DF_VERIFY_SCHEDULED = 1 << 7
};
struct df_ref_info
{
df_ref *refs;
unsigned int *begin;
unsigned int *count;
unsigned int refs_size;
unsigned int table_size;
unsigned int total_size;
enum df_ref_order ref_order;
};
struct df_reg_info
{
df_ref reg_chain;
unsigned int n_refs;
};
# 527 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
class df_d
{
public:
# 539 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
struct dataflow *problems_in_order[DF_LAST_PROBLEM_PLUS1];
struct dataflow *problems_by_index[DF_LAST_PROBLEM_PLUS1];
bitmap blocks_to_analyze;
struct df_ref_info def_info;
struct df_ref_info use_info;
struct df_reg_info **def_regs;
struct df_reg_info **use_regs;
struct df_reg_info **eq_use_regs;
unsigned int regs_size;
unsigned int regs_inited;
struct df_insn_info **insns;
unsigned int insns_size;
int num_problems_defined;
bitmap_head hardware_regs_used;
bitmap_head regular_block_artificial_uses;
bitmap_head eh_block_artificial_uses;
bitmap entry_block_defs;
bitmap exit_block_uses;
bitmap_head insns_to_delete;
bitmap_head insns_to_rescan;
bitmap_head insns_to_notes_rescan;
int *postorder;
vec<int> postorder_inverted;
int n_blocks;
# 600 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
unsigned int *hard_regs_live_count;
unsigned int ref_order;
int changeable_flags : 8;
bool analyze_subset;
bool redo_entry_and_exit;
};
# 805 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
extern bitmap_obstack df_bitmap_obstack;
struct df_scan_bb_info
{
# 820 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
df_ref artificial_defs;
df_ref artificial_uses;
};
class df_rd_bb_info
{
public:
bitmap_head kill;
bitmap_head sparse_kill;
bitmap_head gen;
bitmap_head in;
bitmap_head out;
};
class df_md_bb_info
{
public:
bitmap_head gen;
bitmap_head kill;
bitmap_head init;
bitmap_head in;
bitmap_head out;
};
class df_lr_bb_info
{
public:
bitmap_head def;
bitmap_head use;
bitmap_head in;
bitmap_head out;
};
class df_live_bb_info
{
public:
bitmap_head kill;
bitmap_head gen;
bitmap_head in;
bitmap_head out;
};
class df_word_lr_bb_info
{
public:
bitmap_head def;
bitmap_head use;
bitmap_head in;
bitmap_head out;
};
class df_mir_bb_info
{
public:
bitmap_head kill;
bitmap_head gen;
bitmap_head in;
bitmap_head out;
};
extern class df_d *df;
# 963 "/home/giulianob/gcc_git_gnu/gcc/gcc/df.h"
extern void df_add_problem (const struct df_problem *);
extern int df_set_flags (int);
extern int df_clear_flags (int);
extern void df_set_blocks (bitmap);
extern void df_remove_problem (struct dataflow *);
extern void df_finish_pass (bool);
extern void df_analyze_problem (struct dataflow *, bitmap, int *, int);
extern void df_analyze ();
extern void df_analyze_loop (class loop *);
extern int df_get_n_blocks (enum df_flow_dir);
extern int *df_get_postorder (enum df_flow_dir);
extern void df_simple_dataflow (enum df_flow_dir, df_init_function,
df_confluence_function_0, df_confluence_function_n,
df_transfer_function, bitmap, int *, int);
extern void df_mark_solutions_dirty (void);
extern bool df_get_bb_dirty (basic_block);
extern void df_set_bb_dirty (basic_block);
extern void df_compact_blocks (void);
extern void df_bb_replace (int, basic_block);
extern void df_bb_delete (int);
extern void df_verify (void);
extern df_ref df_bb_regno_first_def_find (basic_block, unsigned int);
extern df_ref df_bb_regno_last_def_find (basic_block, unsigned int);
extern df_ref df_find_def (rtx_insn *, rtx);
extern bool df_reg_defined (rtx_insn *, rtx);
extern df_ref df_find_use (rtx_insn *, rtx);
extern bool df_reg_used (rtx_insn *, rtx);
extern void df_worklist_dataflow (struct dataflow *,bitmap, int *, int);
extern void df_print_regset (FILE *file, const_bitmap r);
extern void df_print_word_regset (FILE *file, const_bitmap r);
extern void df_dump (FILE *);
extern void df_dump_region (FILE *);
extern void df_dump_start (FILE *);
extern void df_dump_top (basic_block, FILE *);
extern void df_dump_bottom (basic_block, FILE *);
extern void df_dump_insn_top (const rtx_insn *, FILE *);
extern void df_dump_insn_bottom (const rtx_insn *, FILE *);
extern void df_refs_chain_dump (df_ref, bool, FILE *);
extern void df_regs_chain_dump (df_ref, FILE *);
extern void df_insn_debug (rtx_insn *, bool, FILE *);
extern void df_insn_debug_regno (rtx_insn *, FILE *);
extern void df_regno_debug (unsigned int, FILE *);
extern void df_ref_debug (df_ref, FILE *);
extern void debug_df_insn (rtx_insn *);
extern void debug_df_regno (unsigned int);
extern void debug_df_reg (rtx);
extern void debug_df_defno (unsigned int);
extern void debug_df_useno (unsigned int);
extern void debug_df_ref (df_ref);
extern void debug_df_chain (struct df_link *);
extern struct df_link *df_chain_create (df_ref, df_ref);
extern void df_chain_unlink (df_ref);
extern void df_chain_copy (df_ref, struct df_link *);
extern void df_grow_bb_info (struct dataflow *);
extern void df_chain_dump (struct df_link *, FILE *);
extern void df_print_bb_index (basic_block bb, FILE *file);
extern void df_rd_add_problem (void);
extern void df_rd_simulate_artificial_defs_at_top (basic_block, bitmap);
extern void df_rd_simulate_one_insn (basic_block, rtx_insn *, bitmap);
extern void df_lr_add_problem (void);
extern void df_lr_verify_transfer_functions (void);
extern void df_live_verify_transfer_functions (void);
extern void df_live_add_problem (void);
extern void df_live_set_all_dirty (void);
extern void df_chain_add_problem (unsigned int);
extern void df_word_lr_add_problem (void);
extern bool df_word_lr_mark_ref (df_ref, bool, bitmap);
extern bool df_word_lr_simulate_defs (rtx_insn *, bitmap);
extern void df_word_lr_simulate_uses (rtx_insn *, bitmap);
extern void df_word_lr_simulate_artificial_refs_at_top (basic_block, bitmap);
extern void df_word_lr_simulate_artificial_refs_at_end (basic_block, bitmap);
extern void df_note_add_problem (void);
extern void df_md_add_problem (void);
extern void df_md_simulate_artificial_defs_at_top (basic_block, bitmap);
extern void df_md_simulate_one_insn (basic_block, rtx_insn *, bitmap);
extern void df_mir_add_problem (void);
extern void df_mir_simulate_one_insn (basic_block, rtx_insn *, bitmap, bitmap);
extern void df_simulate_find_noclobber_defs (rtx_insn *, bitmap);
extern void df_simulate_find_defs (rtx_insn *, bitmap);
extern void df_simulate_defs (rtx_insn *, bitmap);
extern void df_simulate_uses (rtx_insn *, bitmap);
extern void df_simulate_initialize_backwards (basic_block, bitmap);
extern void df_simulate_one_insn_backwards (basic_block, rtx_insn *, bitmap);
extern void df_simulate_finalize_backwards (basic_block, bitmap);
extern void df_simulate_initialize_forwards (basic_block, bitmap);
extern void df_simulate_one_insn_forwards (basic_block, rtx_insn *, bitmap);
extern void simulate_backwards_to_point (basic_block, regset, rtx);
extern bool can_move_insns_across (rtx_insn *, rtx_insn *,
rtx_insn *, rtx_insn *,
basic_block, regset,
regset, rtx_insn **);
extern void df_scan_alloc (bitmap);
extern void df_scan_add_problem (void);
extern void df_grow_reg_info (void);
extern void df_grow_insn_info (void);
extern void df_scan_blocks (void);
extern void df_uses_create (rtx *, rtx_insn *, int);
extern struct df_insn_info * df_insn_create_insn_record (rtx_insn *);
extern void df_insn_delete (rtx_insn *);
extern void df_bb_refs_record (int, bool);
extern bool df_insn_rescan (rtx_insn *);
extern bool df_insn_rescan_debug_internal (rtx_insn *);
extern void df_insn_rescan_all (void);
extern void df_process_deferred_rescans (void);
extern void df_recompute_luids (basic_block);
extern void df_insn_change_bb (rtx_insn *, basic_block);
extern void df_maybe_reorganize_use_refs (enum df_ref_order);
extern void df_maybe_reorganize_def_refs (enum df_ref_order);
extern void df_ref_change_reg_with_loc (rtx, unsigned int);
extern void df_notes_rescan (rtx_insn *);
extern void df_hard_reg_init (void);
extern void df_update_entry_block_defs (void);
extern void df_update_exit_block_uses (void);
extern void df_update_entry_exit_and_calls (void);
extern bool df_hard_reg_used_p (unsigned int);
extern unsigned int df_hard_reg_used_count (unsigned int);
extern bool df_regs_ever_live_p (unsigned int);
extern void df_set_regs_ever_live (unsigned int, bool);
extern void df_compute_regs_ever_live (bool);
extern void df_scan_verify (void);
static inline struct df_scan_bb_info *
df_scan_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_SCAN])->block_info_size)
return &((struct df_scan_bb_info *) (df->problems_by_index[DF_SCAN])->block_info)[index];
else
return nullptr;
}
static inline class df_rd_bb_info *
df_rd_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_RD])->block_info_size)
return &((class df_rd_bb_info *) (df->problems_by_index[DF_RD])->block_info)[index];
else
return nullptr;
}
static inline class df_lr_bb_info *
df_lr_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_LR])->block_info_size)
return &((class df_lr_bb_info *) (df->problems_by_index[DF_LR])->block_info)[index];
else
return nullptr;
}
static inline class df_md_bb_info *
df_md_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_MD])->block_info_size)
return &((class df_md_bb_info *) (df->problems_by_index[DF_MD])->block_info)[index];
else
return nullptr;
}
static inline class df_live_bb_info *
df_live_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_LIVE])->block_info_size)
return &((class df_live_bb_info *) (df->problems_by_index[DF_LIVE])->block_info)[index];
else
return nullptr;
}
static inline class df_word_lr_bb_info *
df_word_lr_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_WORD_LR])->block_info_size)
return &((class df_word_lr_bb_info *) (df->problems_by_index[DF_WORD_LR])->block_info)[index];
else
return nullptr;
}
static inline class df_mir_bb_info *
df_mir_get_bb_info (unsigned int index)
{
if (index < (df->problems_by_index[DF_MIR])->block_info_size)
return &((class df_mir_bb_info *) (df->problems_by_index[DF_MIR])->block_info)[index];
else
return nullptr;
}
static inline bitmap
df_get_live_out (basic_block bb)
{
((void)(!((df->problems_by_index[DF_LR])) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/df.h", 1168, __FUNCTION__), 0 : 0));
if ((df->problems_by_index[DF_LIVE]))
return (&(df_live_get_bb_info ((bb)->index))->out);
else
return (&(df_lr_get_bb_info ((bb)->index))->out);
}
static inline bitmap
df_get_live_in (basic_block bb)
{
((void)(!((df->problems_by_index[DF_LR])) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/df.h", 1184, __FUNCTION__), 0 : 0));
if ((df->problems_by_index[DF_LIVE]))
return (&(df_live_get_bb_info ((bb)->index))->in);
else
return (&(df_lr_get_bb_info ((bb)->index))->in);
}
static inline df_ref
df_get_artificial_defs (unsigned int bb_index)
{
return df_scan_get_bb_info (bb_index)->artificial_defs;
}
static inline df_ref
df_get_artificial_uses (unsigned int bb_index)
{
return df_scan_get_bb_info (bb_index)->artificial_uses;
}
static inline df_ref
df_single_def (const df_insn_info *info)
{
df_ref defs = ((info)->defs);
return defs && !((defs)->base.next_loc) ? defs : nullptr;
}
static inline df_ref
df_single_use (const df_insn_info *info)
{
df_ref uses = ((info)->uses);
return uses && !((uses)->base.next_loc) ? uses : nullptr;
}
struct web_entry_base
{
private:
web_entry_base *pred_pvt;
public:
web_entry_base *pred () { return pred_pvt; }
void set_pred (web_entry_base *p) { pred_pvt = p; }
web_entry_base *unionfind_root ();
friend bool unionfind_union (web_entry_base *first, web_entry_base *second);
};
# 102 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/memmodel.h" 1
# 37 "/home/giulianob/gcc_git_gnu/gcc/gcc/memmodel.h"
enum memmodel
{
MEMMODEL_RELAXED = 0,
MEMMODEL_CONSUME = 1,
MEMMODEL_ACQUIRE = 2,
MEMMODEL_RELEASE = 3,
MEMMODEL_ACQ_REL = 4,
MEMMODEL_SEQ_CST = 5,
MEMMODEL_LAST = 6,
MEMMODEL_SYNC_ACQUIRE = MEMMODEL_ACQUIRE | (1<<15),
MEMMODEL_SYNC_RELEASE = MEMMODEL_RELEASE | (1<<15),
MEMMODEL_SYNC_SEQ_CST = MEMMODEL_SEQ_CST | (1<<15),
MEMMODEL_MAX = ((int) (~ (int) 0 - ((int) ((! ((int) 0 < (int) -1)) ? (int) 1 << (sizeof (int) * 8 - 1) : (int) 0))))
};
static inline enum memmodel
memmodel_from_int (unsigned long val)
{
return (enum memmodel) (val & ((1<<16)-1));
}
static inline enum memmodel
memmodel_base (unsigned long val)
{
return (enum memmodel) (val & ((1<<15)-1));
}
static inline bool
is_mm_relaxed (enum memmodel model)
{
return (model & ((1<<15)-1)) == MEMMODEL_RELAXED;
}
static inline bool
is_mm_consume (enum memmodel model)
{
return (model & ((1<<15)-1)) == MEMMODEL_CONSUME;
}
static inline bool
is_mm_acquire (enum memmodel model)
{
return (model & ((1<<15)-1)) == MEMMODEL_ACQUIRE;
}
static inline bool
is_mm_release (enum memmodel model)
{
return (model & ((1<<15)-1)) == MEMMODEL_RELEASE;
}
static inline bool
is_mm_acq_rel (enum memmodel model)
{
return (model & ((1<<15)-1)) == MEMMODEL_ACQ_REL;
}
static inline bool
is_mm_seq_cst (enum memmodel model)
{
return (model & ((1<<15)-1)) == MEMMODEL_SEQ_CST;
}
static inline bool
is_mm_sync (enum memmodel model)
{
return (model & (1<<15));
}
# 103 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-query.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-query.h"
# 1 "./insn-opinit.h" 1
enum optab_tag {
unknown_optab,
sext_optab,
trunc_optab,
zext_optab,
sfix_optab,
ufix_optab,
sfloat_optab,
ufloat_optab,
lrint_optab,
lround_optab,
lfloor_optab,
lceil_optab,
fract_optab,
fractuns_optab,
satfract_optab,
satfractuns_optab,
sfixtrunc_optab,
ufixtrunc_optab,
smul_widen_optab,
umul_widen_optab,
usmul_widen_optab,
smadd_widen_optab,
umadd_widen_optab,
ssmadd_widen_optab,
usmadd_widen_optab,
smsub_widen_optab,
umsub_widen_optab,
ssmsub_widen_optab,
usmsub_widen_optab,
vec_load_lanes_optab,
vec_store_lanes_optab,
vec_mask_load_lanes_optab,
vec_mask_store_lanes_optab,
vcond_optab,
vcondu_optab,
vcondeq_optab,
vcond_mask_optab,
vec_cmp_optab,
vec_cmpu_optab,
vec_cmpeq_optab,
maskload_optab,
maskstore_optab,
gather_load_optab,
mask_gather_load_optab,
scatter_store_optab,
mask_scatter_store_optab,
vec_extract_optab,
vec_init_optab,
while_ult_optab,
add_optab,
addv_optab,
ssadd_optab,
usadd_optab,
sub_optab,
subv_optab,
sssub_optab,
ussub_optab,
smul_optab,
smulv_optab,
ssmul_optab,
usmul_optab,
sdiv_optab,
sdivv_optab,
ssdiv_optab,
udiv_optab,
usdiv_optab,
sdivmod_optab,
udivmod_optab,
smod_optab,
umod_optab,
ftrunc_optab,
and_optab,
ior_optab,
xor_optab,
ashl_optab,
ssashl_optab,
usashl_optab,
ashr_optab,
lshr_optab,
rotl_optab,
rotr_optab,
vashl_optab,
vashr_optab,
vlshr_optab,
vrotl_optab,
vrotr_optab,
smin_optab,
smax_optab,
umin_optab,
umax_optab,
neg_optab,
negv_optab,
ssneg_optab,
usneg_optab,
abs_optab,
absv_optab,
one_cmpl_optab,
bswap_optab,
ffs_optab,
clz_optab,
ctz_optab,
clrsb_optab,
popcount_optab,
parity_optab,
cmp_optab,
ucmp_optab,
eq_optab,
ne_optab,
gt_optab,
ge_optab,
lt_optab,
le_optab,
unord_optab,
powi_optab,
sqrt_optab,
sync_old_add_optab,
sync_old_sub_optab,
sync_old_ior_optab,
sync_old_and_optab,
sync_old_xor_optab,
sync_old_nand_optab,
sync_new_add_optab,
sync_new_sub_optab,
sync_new_ior_optab,
sync_new_and_optab,
sync_new_xor_optab,
sync_new_nand_optab,
sync_compare_and_swap_optab,
sync_lock_test_and_set_optab,
mov_optab,
movstrict_optab,
movmisalign_optab,
storent_optab,
insv_optab,
extv_optab,
extzv_optab,
insvmisalign_optab,
extvmisalign_optab,
extzvmisalign_optab,
push_optab,
reload_in_optab,
reload_out_optab,
cbranch_optab,
addcc_optab,
negcc_optab,
notcc_optab,
movcc_optab,
cond_add_optab,
cond_sub_optab,
cond_smul_optab,
cond_sdiv_optab,
cond_smod_optab,
cond_udiv_optab,
cond_umod_optab,
cond_and_optab,
cond_ior_optab,
cond_xor_optab,
cond_ashl_optab,
cond_ashr_optab,
cond_lshr_optab,
cond_smin_optab,
cond_smax_optab,
cond_umin_optab,
cond_umax_optab,
cond_fma_optab,
cond_fms_optab,
cond_fnma_optab,
cond_fnms_optab,
cmov_optab,
cstore_optab,
ctrap_optab,
addv4_optab,
subv4_optab,
mulv4_optab,
uaddv4_optab,
usubv4_optab,
umulv4_optab,
negv3_optab,
addptr3_optab,
smul_highpart_optab,
umul_highpart_optab,
cmpmem_optab,
cmpstr_optab,
cmpstrn_optab,
cpymem_optab,
movmem_optab,
setmem_optab,
strlen_optab,
fma_optab,
fms_optab,
fnma_optab,
fnms_optab,
rint_optab,
round_optab,
roundeven_optab,
floor_optab,
ceil_optab,
btrunc_optab,
nearbyint_optab,
acos_optab,
acosh_optab,
asin_optab,
asinh_optab,
atan2_optab,
atan_optab,
atanh_optab,
copysign_optab,
xorsign_optab,
cos_optab,
cosh_optab,
exp10_optab,
exp2_optab,
exp_optab,
expm1_optab,
fmod_optab,
hypot_optab,
ilogb_optab,
isinf_optab,
ldexp_optab,
log10_optab,
log1p_optab,
log2_optab,
log_optab,
logb_optab,
pow_optab,
remainder_optab,
rsqrt_optab,
scalb_optab,
signbit_optab,
significand_optab,
sin_optab,
sincos_optab,
sinh_optab,
tan_optab,
tanh_optab,
fmax_optab,
fmin_optab,
reduc_smax_scal_optab,
reduc_smin_scal_optab,
reduc_plus_scal_optab,
reduc_umax_scal_optab,
reduc_umin_scal_optab,
reduc_and_scal_optab,
reduc_ior_scal_optab,
reduc_xor_scal_optab,
fold_left_plus_optab,
mask_fold_left_plus_optab,
extract_last_optab,
fold_extract_last_optab,
savg_floor_optab,
uavg_floor_optab,
savg_ceil_optab,
uavg_ceil_optab,
sdot_prod_optab,
ssum_widen_optab,
udot_prod_optab,
usum_widen_optab,
usad_optab,
ssad_optab,
smulhs_optab,
smulhrs_optab,
umulhs_optab,
umulhrs_optab,
sdiv_pow2_optab,
vec_pack_sfix_trunc_optab,
vec_pack_ssat_optab,
vec_pack_trunc_optab,
vec_pack_ufix_trunc_optab,
vec_pack_sbool_trunc_optab,
vec_pack_usat_optab,
vec_packs_float_optab,
vec_packu_float_optab,
vec_perm_optab,
vec_realign_load_optab,
vec_set_optab,
vec_shl_optab,
vec_shr_optab,
vec_unpack_sfix_trunc_hi_optab,
vec_unpack_sfix_trunc_lo_optab,
vec_unpack_ufix_trunc_hi_optab,
vec_unpack_ufix_trunc_lo_optab,
vec_unpacks_float_hi_optab,
vec_unpacks_float_lo_optab,
vec_unpacks_hi_optab,
vec_unpacks_lo_optab,
vec_unpacks_sbool_hi_optab,
vec_unpacks_sbool_lo_optab,
vec_unpacku_float_hi_optab,
vec_unpacku_float_lo_optab,
vec_unpacku_hi_optab,
vec_unpacku_lo_optab,
vec_widen_smult_even_optab,
vec_widen_smult_hi_optab,
vec_widen_smult_lo_optab,
vec_widen_smult_odd_optab,
vec_widen_sshiftl_hi_optab,
vec_widen_sshiftl_lo_optab,
vec_widen_umult_even_optab,
vec_widen_umult_hi_optab,
vec_widen_umult_lo_optab,
vec_widen_umult_odd_optab,
vec_widen_ushiftl_hi_optab,
vec_widen_ushiftl_lo_optab,
sync_add_optab,
sync_and_optab,
sync_ior_optab,
sync_lock_release_optab,
sync_nand_optab,
sync_sub_optab,
sync_xor_optab,
atomic_add_fetch_optab,
atomic_add_optab,
atomic_and_fetch_optab,
atomic_and_optab,
atomic_bit_test_and_set_optab,
atomic_bit_test_and_complement_optab,
atomic_bit_test_and_reset_optab,
atomic_compare_and_swap_optab,
atomic_exchange_optab,
atomic_fetch_add_optab,
atomic_fetch_and_optab,
atomic_fetch_nand_optab,
atomic_fetch_or_optab,
atomic_fetch_sub_optab,
atomic_fetch_xor_optab,
atomic_load_optab,
atomic_nand_fetch_optab,
atomic_nand_optab,
atomic_or_fetch_optab,
atomic_or_optab,
atomic_store_optab,
atomic_sub_fetch_optab,
atomic_sub_optab,
atomic_xor_fetch_optab,
atomic_xor_optab,
get_thread_pointer_optab,
set_thread_pointer_optab,
check_raw_ptrs_optab,
check_war_ptrs_optab,
vec_duplicate_optab,
vec_series_optab,
vec_shl_insert_optab,
len_load_optab,
len_store_optab,
FIRST_CONV_OPTAB = sext_optab,
LAST_CONVLIB_OPTAB = satfractuns_optab,
LAST_CONV_OPTAB = while_ult_optab,
FIRST_NORM_OPTAB = add_optab,
LAST_NORMLIB_OPTAB = sync_lock_test_and_set_optab,
LAST_NORM_OPTAB = len_store_optab
};
typedef enum optab_tag optab;
typedef enum optab_tag convert_optab;
typedef enum optab_tag direct_optab;
struct optab_libcall_d
{
char libcall_suffix;
const char *libcall_basename;
void (*libcall_gen) (optab, const char *name,
char suffix, machine_mode);
};
struct convert_optab_libcall_d
{
const char *libcall_basename;
void (*libcall_gen) (convert_optab, const char *name,
machine_mode, machine_mode);
};
extern const optab code_to_optab_[((int) LAST_AND_UNUSED_RTX_CODE)];
extern const enum rtx_code optab_to_code_[344];
static inline optab
code_to_optab (enum rtx_code code)
{
return code_to_optab_[code];
}
static inline enum rtx_code
optab_to_code (optab op)
{
return optab_to_code_[op];
}
extern insn_code maybe_code_for_cmp_1 (machine_mode);
inline insn_code
code_for_cmp_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_cmp_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 408, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_cmp_1 (machine_mode, rtx, rtx);
inline rtx
gen_cmp_1 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_cmp_1 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 417, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_insv_1 (machine_mode);
inline insn_code
code_for_insv_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_insv_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 426, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_insv_1 (machine_mode, rtx, rtx);
inline rtx
gen_insv_1 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_insv_1 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 435, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_add3_carry (machine_mode);
inline insn_code
code_for_add3_carry (machine_mode arg0)
{
insn_code code = maybe_code_for_add3_carry (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 444, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_add3_carry (machine_mode, rtx, rtx, rtx, rtx, rtx);
inline rtx
gen_add3_carry (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
{
rtx res = maybe_gen_add3_carry (arg0, x0, x1, x2, x3, x4);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 453, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_sub3_carry (machine_mode);
inline insn_code
code_for_sub3_carry (machine_mode arg0)
{
insn_code code = maybe_code_for_sub3_carry (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 462, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_sub3_carry (machine_mode, rtx, rtx, rtx, rtx, rtx);
inline rtx
gen_sub3_carry (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
{
rtx res = maybe_gen_sub3_carry (arg0, x0, x1, x2, x3, x4);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 471, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_sub3_carry_ccc (machine_mode);
inline insn_code
code_for_sub3_carry_ccc (machine_mode arg0)
{
insn_code code = maybe_code_for_sub3_carry_ccc (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 480, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_sub3_carry_ccc (machine_mode, rtx, rtx, rtx);
inline rtx
gen_sub3_carry_ccc (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_sub3_carry_ccc (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 489, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_sub3_carry_ccgz (machine_mode);
inline insn_code
code_for_sub3_carry_ccgz (machine_mode arg0)
{
insn_code code = maybe_code_for_sub3_carry_ccgz (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 498, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_sub3_carry_ccgz (machine_mode, rtx, rtx, rtx);
inline rtx
gen_sub3_carry_ccgz (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_sub3_carry_ccgz (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 507, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_test_ccno_1 (machine_mode);
inline insn_code
code_for_test_ccno_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_test_ccno_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 516, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_test_ccno_1 (machine_mode, rtx, rtx);
inline rtx
gen_test_ccno_1 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_test_ccno_1 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 525, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_copysign3_const (machine_mode);
inline insn_code
code_for_copysign3_const (machine_mode arg0)
{
insn_code code = maybe_code_for_copysign3_const (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 534, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_copysign3_const (machine_mode, rtx, rtx, rtx, rtx);
inline rtx
gen_copysign3_const (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
{
rtx res = maybe_gen_copysign3_const (arg0, x0, x1, x2, x3);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 543, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_copysign3_var (machine_mode);
inline insn_code
code_for_copysign3_var (machine_mode arg0)
{
insn_code code = maybe_code_for_copysign3_var (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 552, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_copysign3_var (machine_mode, rtx, rtx, rtx, rtx, rtx, rtx);
inline rtx
gen_copysign3_var (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4, rtx x5)
{
rtx res = maybe_gen_copysign3_var (arg0, x0, x1, x2, x3, x4, x5);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 561, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_xorsign3_1 (machine_mode);
inline insn_code
code_for_xorsign3_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_xorsign3_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 570, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_xorsign3_1 (machine_mode, rtx, rtx, rtx, rtx);
inline rtx
gen_xorsign3_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
{
rtx res = maybe_gen_xorsign3_1 (arg0, x0, x1, x2, x3);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 579, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_x86_shift_adj_1 (machine_mode);
inline insn_code
code_for_x86_shift_adj_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_x86_shift_adj_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 588, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_x86_shift_adj_1 (machine_mode, rtx, rtx, rtx, rtx);
inline rtx
gen_x86_shift_adj_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
{
rtx res = maybe_gen_x86_shift_adj_1 (arg0, x0, x1, x2, x3);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 597, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_x86_shift_adj_2 (machine_mode);
inline insn_code
code_for_x86_shift_adj_2 (machine_mode arg0)
{
insn_code code = maybe_code_for_x86_shift_adj_2 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 606, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_x86_shift_adj_2 (machine_mode, rtx, rtx, rtx);
inline rtx
gen_x86_shift_adj_2 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_x86_shift_adj_2 (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 615, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_x86_shift_adj_3 (machine_mode);
inline insn_code
code_for_x86_shift_adj_3 (machine_mode arg0)
{
insn_code code = maybe_code_for_x86_shift_adj_3 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 624, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_x86_shift_adj_3 (machine_mode, rtx, rtx, rtx);
inline rtx
gen_x86_shift_adj_3 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_x86_shift_adj_3 (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 633, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_leave (machine_mode);
inline insn_code
code_for_leave (machine_mode arg0)
{
insn_code code = maybe_code_for_leave (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 642, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_leave (machine_mode);
inline rtx
gen_leave (machine_mode arg0)
{
rtx res = maybe_gen_leave (arg0);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 651, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_tls_global_dynamic_64 (machine_mode);
inline insn_code
code_for_tls_global_dynamic_64 (machine_mode arg0)
{
insn_code code = maybe_code_for_tls_global_dynamic_64 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 660, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_tls_global_dynamic_64 (machine_mode, rtx, rtx, rtx);
inline rtx
gen_tls_global_dynamic_64 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_tls_global_dynamic_64 (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 669, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_tls_local_dynamic_base_64 (machine_mode);
inline insn_code
code_for_tls_local_dynamic_base_64 (machine_mode arg0)
{
insn_code code = maybe_code_for_tls_local_dynamic_base_64 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 678, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_tls_local_dynamic_base_64 (machine_mode, rtx, rtx);
inline rtx
gen_tls_local_dynamic_base_64 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_tls_local_dynamic_base_64 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 687, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_tls_dynamic_gnu2_64 (machine_mode);
inline insn_code
code_for_tls_dynamic_gnu2_64 (machine_mode arg0)
{
insn_code code = maybe_code_for_tls_dynamic_gnu2_64 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 696, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_tls_dynamic_gnu2_64 (machine_mode, rtx, rtx);
inline rtx
gen_tls_dynamic_gnu2_64 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_tls_dynamic_gnu2_64 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 705, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_pro_epilogue_adjust_stack_add (machine_mode);
inline insn_code
code_for_pro_epilogue_adjust_stack_add (machine_mode arg0)
{
insn_code code = maybe_code_for_pro_epilogue_adjust_stack_add (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 714, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_pro_epilogue_adjust_stack_add (machine_mode, rtx, rtx, rtx);
inline rtx
gen_pro_epilogue_adjust_stack_add (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_pro_epilogue_adjust_stack_add (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 723, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_pro_epilogue_adjust_stack_sub (machine_mode);
inline insn_code
code_for_pro_epilogue_adjust_stack_sub (machine_mode arg0)
{
insn_code code = maybe_code_for_pro_epilogue_adjust_stack_sub (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 732, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_pro_epilogue_adjust_stack_sub (machine_mode, rtx, rtx, rtx);
inline rtx
gen_pro_epilogue_adjust_stack_sub (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_pro_epilogue_adjust_stack_sub (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 741, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_allocate_stack_worker_probe (machine_mode);
inline insn_code
code_for_allocate_stack_worker_probe (machine_mode arg0)
{
insn_code code = maybe_code_for_allocate_stack_worker_probe (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 750, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_allocate_stack_worker_probe (machine_mode, rtx, rtx);
inline rtx
gen_allocate_stack_worker_probe (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_allocate_stack_worker_probe (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 759, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_probe_stack_1 (machine_mode);
inline insn_code
code_for_probe_stack_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_probe_stack_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 768, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_probe_stack_1 (machine_mode, rtx, rtx);
inline rtx
gen_probe_stack_1 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_probe_stack_1 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 777, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_adjust_stack_and_probe (machine_mode);
inline insn_code
code_for_adjust_stack_and_probe (machine_mode arg0)
{
insn_code code = maybe_code_for_adjust_stack_and_probe (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 786, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_adjust_stack_and_probe (machine_mode, rtx, rtx, rtx);
inline rtx
gen_adjust_stack_and_probe (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_adjust_stack_and_probe (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 795, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_probe_stack_range (machine_mode);
inline insn_code
code_for_probe_stack_range (machine_mode arg0)
{
insn_code code = maybe_code_for_probe_stack_range (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 804, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_probe_stack_range (machine_mode, rtx, rtx, rtx);
inline rtx
gen_probe_stack_range (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_probe_stack_range (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 813, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_stack_protect_set_1 (machine_mode);
inline insn_code
code_for_stack_protect_set_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_stack_protect_set_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 822, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_stack_protect_set_1 (machine_mode, rtx, rtx);
inline rtx
gen_stack_protect_set_1 (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_stack_protect_set_1 (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 831, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_stack_protect_test_1 (machine_mode);
inline insn_code
code_for_stack_protect_test_1 (machine_mode arg0)
{
insn_code code = maybe_code_for_stack_protect_test_1 (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 840, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_stack_protect_test_1 (machine_mode, rtx, rtx, rtx);
inline rtx
gen_stack_protect_test_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_stack_protect_test_1 (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 849, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_lwp_llwpcb (machine_mode);
inline insn_code
code_for_lwp_llwpcb (machine_mode arg0)
{
insn_code code = maybe_code_for_lwp_llwpcb (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 858, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_lwp_llwpcb (machine_mode, rtx);
inline rtx
gen_lwp_llwpcb (machine_mode arg0, rtx x0)
{
rtx res = maybe_gen_lwp_llwpcb (arg0, x0);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 867, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_lwp_slwpcb (machine_mode);
inline insn_code
code_for_lwp_slwpcb (machine_mode arg0)
{
insn_code code = maybe_code_for_lwp_slwpcb (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 876, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_lwp_slwpcb (machine_mode, rtx);
inline rtx
gen_lwp_slwpcb (machine_mode arg0, rtx x0)
{
rtx res = maybe_gen_lwp_slwpcb (arg0, x0);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 885, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_lwp_lwpval (machine_mode);
inline insn_code
code_for_lwp_lwpval (machine_mode arg0)
{
insn_code code = maybe_code_for_lwp_lwpval (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 894, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_lwp_lwpval (machine_mode, rtx, rtx, rtx);
inline rtx
gen_lwp_lwpval (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_lwp_lwpval (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 903, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_lwp_lwpins (machine_mode);
inline insn_code
code_for_lwp_lwpins (machine_mode arg0)
{
insn_code code = maybe_code_for_lwp_lwpins (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 912, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_lwp_lwpins (machine_mode, rtx, rtx, rtx);
inline rtx
gen_lwp_lwpins (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_lwp_lwpins (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 921, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_rdssp (machine_mode);
inline insn_code
code_for_rdssp (machine_mode arg0)
{
insn_code code = maybe_code_for_rdssp (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 930, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_rdssp (machine_mode, rtx, rtx);
inline rtx
gen_rdssp (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_rdssp (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 939, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_incssp (machine_mode);
inline insn_code
code_for_incssp (machine_mode arg0)
{
insn_code code = maybe_code_for_incssp (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 948, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_incssp (machine_mode, rtx);
inline rtx
gen_incssp (machine_mode arg0, rtx x0)
{
rtx res = maybe_gen_incssp (arg0, x0);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 957, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_wrss (machine_mode);
inline insn_code
code_for_wrss (machine_mode arg0)
{
insn_code code = maybe_code_for_wrss (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 966, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_wrss (machine_mode, rtx, rtx);
inline rtx
gen_wrss (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_wrss (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 975, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_wruss (machine_mode);
inline insn_code
code_for_wruss (machine_mode arg0)
{
insn_code code = maybe_code_for_wruss (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 984, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_wruss (machine_mode, rtx, rtx);
inline rtx
gen_wruss (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_wruss (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 993, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_monitorx (machine_mode);
inline insn_code
code_for_monitorx (machine_mode arg0)
{
insn_code code = maybe_code_for_monitorx (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 1002, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_monitorx (machine_mode, rtx, rtx, rtx);
inline rtx
gen_monitorx (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_monitorx (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 1011, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_clzero (machine_mode);
inline insn_code
code_for_clzero (machine_mode arg0)
{
insn_code code = maybe_code_for_clzero (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 1020, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_clzero (machine_mode, rtx);
inline rtx
gen_clzero (machine_mode arg0, rtx x0)
{
rtx res = maybe_gen_clzero (arg0, x0);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 1029, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_movdir64b (machine_mode);
inline insn_code
code_for_movdir64b (machine_mode arg0)
{
insn_code code = maybe_code_for_movdir64b (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 1038, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_movdir64b (machine_mode, rtx, rtx);
inline rtx
gen_movdir64b (machine_mode arg0, rtx x0, rtx x1)
{
rtx res = maybe_gen_movdir64b (arg0, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 1047, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_enqcmd (int, machine_mode);
inline insn_code
code_for_enqcmd (int arg0, machine_mode arg1)
{
insn_code code = maybe_code_for_enqcmd (arg0, arg1);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 1056, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_enqcmd (int, machine_mode, rtx, rtx);
inline rtx
gen_enqcmd (int arg0, machine_mode arg1, rtx x0, rtx x1)
{
rtx res = maybe_gen_enqcmd (arg0, arg1, x0, x1);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 1065, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_umonitor (machine_mode);
inline insn_code
code_for_umonitor (machine_mode arg0)
{
insn_code code = maybe_code_for_umonitor (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 1074, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_umonitor (machine_mode, rtx);
inline rtx
gen_umonitor (machine_mode arg0, rtx x0)
{
rtx res = maybe_gen_umonitor (arg0, x0);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 1083, __FUNCTION__), 0 : 0));
return res;
}
extern insn_code maybe_code_for_sse3_monitor (machine_mode);
inline insn_code
code_for_sse3_monitor (machine_mode arg0)
{
insn_code code = maybe_code_for_sse3_monitor (arg0);
((void)(!(code != CODE_FOR_nothing) ? fancy_abort ("./insn-opinit.h", 1092, __FUNCTION__), 0 : 0));
return code;
}
extern rtx maybe_gen_sse3_monitor (machine_mode, rtx, rtx, rtx);
inline rtx
gen_sse3_monitor (machine_mode arg0, rtx x0, rtx x1, rtx x2)
{
rtx res = maybe_gen_sse3_monitor (arg0, x0, x1, x2);
((void)(!(res) ? fancy_abort ("./insn-opinit.h", 1101, __FUNCTION__), 0 : 0));
return res;
}
extern const struct convert_optab_libcall_d convlib_def[15];
extern const struct optab_libcall_d normlib_def[80];
extern enum insn_code raw_optab_handler (unsigned);
extern bool swap_optab_enable (optab, machine_mode, bool);
struct target_optabs {
bool pat_enable[1737];
bool supports_vec_gather_load;
bool supports_vec_gather_load_cached;
bool supports_vec_scatter_store;
bool supports_vec_scatter_store_cached;
};
extern void init_all_optabs (struct target_optabs *);
extern struct target_optabs default_target_optabs;
extern struct target_optabs *this_fn_optabs;
extern struct target_optabs *this_target_optabs;
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-query.h" 2
inline bool
convert_optab_p (optab op)
{
return op > unknown_optab && op <= LAST_CONV_OPTAB;
}
inline enum insn_code
optab_handler (optab op, machine_mode mode)
{
unsigned scode = (op << 16) | mode;
((void)(!(op > LAST_CONV_OPTAB) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-query.h", 41, __FUNCTION__), 0 : 0));
return raw_optab_handler (scode);
}
inline enum insn_code
convert_optab_handler (convert_optab op, machine_mode to_mode,
machine_mode from_mode)
{
unsigned scode = (op << 16) | (from_mode << 8) | to_mode;
((void)(!(convert_optab_p (op)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-query.h", 54, __FUNCTION__), 0 : 0));
return raw_optab_handler (scode);
}
enum insn_code convert_optab_handler (convert_optab, machine_mode,
machine_mode, optimization_type);
inline enum insn_code
direct_optab_handler (direct_optab op, machine_mode mode)
{
return optab_handler (op, mode);
}
enum insn_code direct_optab_handler (convert_optab, machine_mode,
optimization_type);
inline bool
trapv_unoptab_p (optab unoptab)
{
return (unoptab == negv_optab
|| unoptab == absv_optab);
}
inline bool
trapv_binoptab_p (optab binoptab)
{
return (binoptab == addv_optab
|| binoptab == subv_optab
|| binoptab == smulv_optab);
}
static inline enum insn_code
get_vec_cmp_icode (machine_mode vmode, machine_mode mask_mode, bool uns)
{
optab tab = uns ? vec_cmpu_optab : vec_cmp_optab;
return convert_optab_handler (tab, vmode, mask_mode);
}
static inline enum insn_code
get_vec_cmp_eq_icode (machine_mode vmode, machine_mode mask_mode)
{
return convert_optab_handler (vec_cmpeq_optab, vmode, mask_mode);
}
inline enum insn_code
get_vcond_icode (machine_mode vmode, machine_mode cmode, bool uns)
{
enum insn_code icode = CODE_FOR_nothing;
if (uns)
icode = convert_optab_handler (vcondu_optab, vmode, cmode);
else
icode = convert_optab_handler (vcond_optab, vmode, cmode);
return icode;
}
static inline enum insn_code
get_vcond_mask_icode (machine_mode vmode, machine_mode mmode)
{
return convert_optab_handler (vcond_mask_optab, vmode, mmode);
}
static inline enum insn_code
get_vcond_eq_icode (machine_mode vmode, machine_mode cmode)
{
return convert_optab_handler (vcondeq_optab, vmode, cmode);
}
enum extraction_pattern { EP_insv, EP_extv, EP_extzv };
class extraction_insn
{
public:
enum insn_code icode;
opt_scalar_int_mode struct_mode;
scalar_int_mode field_mode;
scalar_int_mode pos_mode;
};
bool get_best_reg_extraction_insn (extraction_insn *,
enum extraction_pattern,
unsigned long, machine_mode);
bool get_best_mem_extraction_insn (extraction_insn *,
enum extraction_pattern,
long, long, machine_mode);
enum insn_code can_extend_p (machine_mode, machine_mode, int);
enum insn_code can_float_p (machine_mode, machine_mode, int);
enum insn_code can_fix_p (machine_mode, machine_mode, int, bool *);
bool can_conditionally_move_p (machine_mode mode);
opt_machine_mode qimode_for_vec_perm (machine_mode);
bool selector_fits_mode_p (machine_mode, const vec_perm_indices &);
bool can_vec_perm_var_p (machine_mode);
bool can_vec_perm_const_p (machine_mode, const vec_perm_indices &,
bool = true);
enum insn_code find_widening_optab_handler_and_mode (optab, machine_mode,
machine_mode,
machine_mode *);
int can_mult_highpart_p (machine_mode, bool);
bool can_vec_mask_load_store_p (machine_mode, machine_mode, bool);
opt_machine_mode get_len_load_store_mode (machine_mode, bool);
bool can_compare_and_swap_p (machine_mode, bool);
bool can_atomic_exchange_p (machine_mode, bool);
bool can_atomic_load_p (machine_mode);
bool lshift_cheap_p (bool);
bool supports_vec_gather_load_p ();
bool supports_vec_scatter_store_p ();
template<typename T>
inline enum insn_code
find_widening_optab_handler_and_mode (optab op, const T &to_mode,
const T &from_mode, T *found_mode)
{
machine_mode tmp;
enum insn_code icode = find_widening_optab_handler_and_mode
(op, machine_mode (to_mode), machine_mode (from_mode), &tmp);
if (icode != CODE_FOR_nothing && found_mode)
*found_mode = as_a <T> (tmp);
return icode;
}
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-libfuncs.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs-libfuncs.h"
rtx convert_optab_libfunc (convert_optab, machine_mode, machine_mode);
rtx optab_libfunc (optab, machine_mode);
void gen_int_libfunc (optab, const char *, char, machine_mode);
void gen_fp_libfunc (optab, const char *, char, machine_mode);
void gen_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_signed_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_unsigned_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_int_fp_libfunc (optab, const char *, char, machine_mode);
void gen_intv_fp_libfunc (optab, const char *, char, machine_mode);
void gen_int_fp_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_int_fp_signed_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_int_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_int_signed_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_int_unsigned_fixed_libfunc (optab, const char *, char, machine_mode);
void gen_interclass_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_int_to_fp_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_ufloat_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_int_to_fp_nondecimal_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_fp_to_int_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_intraclass_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_trunc_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_extend_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_fract_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_fractuns_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_satfract_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
void gen_satfractuns_conv_libfunc (convert_optab, const char *,
machine_mode, machine_mode);
tree build_libfunc_function_visibility (const char *, symbol_visibility);
tree build_libfunc_function (const char *);
rtx init_one_libfunc_visibility (const char *, symbol_visibility);
rtx init_one_libfunc (const char *);
rtx set_user_assembler_libfunc (const char *, const char *);
void set_optab_libfunc (optab, machine_mode, const char *);
void set_conv_libfunc (convert_optab, machine_mode,
machine_mode, const char *);
void init_optabs (void);
void init_sync_libfuncs (int max);
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec-perm-indices.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec-perm-indices.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/int-vector-builder.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/int-vector-builder.h"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h" 1
# 111 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
template<typename T, typename Shape, typename Derived>
class vector_builder : public auto_vec<T, 32>
{
public:
vector_builder ();
poly_uint64 full_nelts () const { return m_full_nelts; }
unsigned int npatterns () const { return m_npatterns; }
unsigned int nelts_per_pattern () const { return m_nelts_per_pattern; }
unsigned int encoded_nelts () const;
bool encoded_full_vector_p () const;
T elt (unsigned int) const;
unsigned int count_dups (int, int, int) const;
bool operator == (const Derived &) const;
bool operator != (const Derived &x) const { return !operator == (x); }
bool new_unary_operation (Shape, T, bool);
bool new_binary_operation (Shape, T, T, bool);
void finalize ();
static unsigned int binary_encoded_nelts (T, T);
protected:
void new_vector (poly_uint64, unsigned int, unsigned int);
void reshape (unsigned int, unsigned int);
bool repeating_sequence_p (unsigned int, unsigned int, unsigned int);
bool stepped_sequence_p (unsigned int, unsigned int, unsigned int);
bool try_npatterns (unsigned int);
private:
vector_builder (const vector_builder &);
vector_builder &operator= (const vector_builder &);
Derived *derived () { return static_cast<Derived *> (this); }
const Derived *derived () const;
poly_uint64 m_full_nelts;
unsigned int m_npatterns;
unsigned int m_nelts_per_pattern;
};
template<typename T, typename Shape, typename Derived>
inline const Derived *
vector_builder<T, Shape, Derived>::derived () const
{
return static_cast<const Derived *> (this);
}
template<typename T, typename Shape, typename Derived>
inline
vector_builder<T, Shape, Derived>::vector_builder ()
: m_full_nelts (0),
m_npatterns (0),
m_nelts_per_pattern (0)
{}
template<typename T, typename Shape, typename Derived>
inline unsigned int
vector_builder<T, Shape, Derived>::encoded_nelts () const
{
return m_npatterns * m_nelts_per_pattern;
}
template<typename T, typename Shape, typename Derived>
inline bool
vector_builder<T, Shape, Derived>::encoded_full_vector_p () const
{
return (!maybe_ne (m_npatterns * m_nelts_per_pattern, m_full_nelts));
}
template<typename T, typename Shape, typename Derived>
void
vector_builder<T, Shape, Derived>::new_vector (poly_uint64 full_nelts,
unsigned int npatterns,
unsigned int nelts_per_pattern)
{
m_full_nelts = full_nelts;
m_npatterns = npatterns;
m_nelts_per_pattern = nelts_per_pattern;
this->reserve (encoded_nelts ());
this->truncate (0);
}
template<typename T, typename Shape, typename Derived>
bool
vector_builder<T, Shape, Derived>::operator == (const Derived &other) const
{
if (maybe_ne (m_full_nelts, other.m_full_nelts)
|| m_npatterns != other.m_npatterns
|| m_nelts_per_pattern != other.m_nelts_per_pattern)
return false;
unsigned int nelts = encoded_nelts ();
for (unsigned int i = 0; i < nelts; ++i)
if (!derived ()->equal_p ((*this)[i], other[i]))
return false;
return true;
}
template<typename T, typename Shape, typename Derived>
T
vector_builder<T, Shape, Derived>::elt (unsigned int i) const
{
if (i < this->length ())
return (*this)[i];
((void)(!(encoded_nelts () <= this->length ()) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 238, __FUNCTION__), 0 : 0));
unsigned int pattern = i % m_npatterns;
unsigned int count = i / m_npatterns;
unsigned int final_i = encoded_nelts () - m_npatterns + pattern;
T final = (*this)[final_i];
if (m_nelts_per_pattern <= 2)
return final;
T prev = (*this)[final_i - m_npatterns];
return derived ()->apply_step (final, count - 2,
derived ()->step (prev, final));
}
# 265 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
template<typename T, typename Shape, typename Derived>
bool
vector_builder<T, Shape, Derived>::new_unary_operation (Shape shape, T vec,
bool allow_stepped_p)
{
poly_uint64 full_nelts = Derived::shape_nelts (shape);
((void)(!((!maybe_ne (full_nelts, Derived::nelts_of (vec)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 271, __FUNCTION__), 0 : 0));
unsigned int npatterns = Derived::npatterns_of (vec);
unsigned int nelts_per_pattern = Derived::nelts_per_pattern_of (vec);
if (!allow_stepped_p && nelts_per_pattern > 2)
{
if (!full_nelts.is_constant ())
return false;
npatterns = full_nelts.to_constant ();
nelts_per_pattern = 1;
}
derived ()->new_vector (shape, npatterns, nelts_per_pattern);
return true;
}
# 293 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
template<typename T, typename Shape, typename Derived>
bool
vector_builder<T, Shape, Derived>::new_binary_operation (Shape shape,
T vec1, T vec2,
bool allow_stepped_p)
{
poly_uint64 full_nelts = Derived::shape_nelts (shape);
((void)(!((!maybe_ne (full_nelts, Derived::nelts_of (vec1))) && (!maybe_ne (full_nelts, Derived::nelts_of (vec2)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 300, __FUNCTION__), 0 : 0))
;
# 321 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
unsigned int npatterns
= least_common_multiple (Derived::npatterns_of (vec1),
Derived::npatterns_of (vec2));
unsigned int nelts_per_pattern
= ((Derived::nelts_per_pattern_of (vec1)) > (Derived::nelts_per_pattern_of (vec2)) ? (Derived::nelts_per_pattern_of (vec1)) : (Derived::nelts_per_pattern_of (vec2)))
;
if (!allow_stepped_p && nelts_per_pattern > 2)
{
if (!full_nelts.is_constant ())
return false;
npatterns = full_nelts.to_constant ();
nelts_per_pattern = 1;
}
derived ()->new_vector (shape, npatterns, nelts_per_pattern);
return true;
}
template<typename T, typename Shape, typename Derived>
unsigned int
vector_builder<T, Shape, Derived>::binary_encoded_nelts (T vec1, T vec2)
{
poly_uint64 nelts = Derived::nelts_of (vec1);
((void)(!((!maybe_ne (nelts, Derived::nelts_of (vec2)))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 348, __FUNCTION__), 0 : 0));
unsigned int npatterns
= least_common_multiple (Derived::npatterns_of (vec1),
Derived::npatterns_of (vec2));
unsigned int nelts_per_pattern
= ((Derived::nelts_per_pattern_of (vec1)) > (Derived::nelts_per_pattern_of (vec2)) ? (Derived::nelts_per_pattern_of (vec1)) : (Derived::nelts_per_pattern_of (vec2)))
;
unsigned long const_nelts;
if (nelts.is_constant (&const_nelts))
return ((npatterns * nelts_per_pattern) < (const_nelts) ? (npatterns * nelts_per_pattern) : (const_nelts));
return npatterns * nelts_per_pattern;
}
template<typename T, typename Shape, typename Derived>
unsigned int
vector_builder<T, Shape, Derived>::count_dups (int start, int end,
int step) const
{
((void)(!((end - start) % step == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 370, __FUNCTION__), 0 : 0));
unsigned int ndups = 1;
for (int i = start + step;
i != end && derived ()->equal_p (elt (i), elt (start));
i += step)
ndups++;
return ndups;
}
template<typename T, typename Shape, typename Derived>
void
vector_builder<T, Shape, Derived>::reshape (unsigned int npatterns,
unsigned int nelts_per_pattern)
{
unsigned int old_encoded_nelts = encoded_nelts ();
unsigned int new_encoded_nelts = npatterns * nelts_per_pattern;
((void)(!(new_encoded_nelts <= old_encoded_nelts) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 390, __FUNCTION__), 0 : 0));
unsigned int next = new_encoded_nelts - npatterns;
for (unsigned int i = new_encoded_nelts; i < old_encoded_nelts; ++i)
{
derived ()->note_representative (&(*this)[next], (*this)[i]);
next += 1;
if (next == new_encoded_nelts)
next -= npatterns;
}
m_npatterns = npatterns;
m_nelts_per_pattern = nelts_per_pattern;
}
template<typename T, typename Shape, typename Derived>
bool
vector_builder<T, Shape, Derived>::repeating_sequence_p (unsigned int start,
unsigned int end,
unsigned int step)
{
for (unsigned int i = start; i < end - step; ++i)
if (!derived ()->equal_p ((*this)[i], (*this)[i + step]))
return false;
return true;
}
template<typename T, typename Shape, typename Derived>
bool
vector_builder<T, Shape, Derived>::stepped_sequence_p (unsigned int start,
unsigned int end,
unsigned int step)
{
if (!derived ()->allow_steps_p ())
return false;
for (unsigned int i = start + step * 2; i < end; ++i)
{
T elt1 = (*this)[i - step * 2];
T elt2 = (*this)[i - step];
T elt3 = (*this)[i];
if (!derived ()->integral_p (elt1)
|| !derived ()->integral_p (elt2)
|| !derived ()->integral_p (elt3))
return false;
if (maybe_ne (derived ()->step (elt1, elt2),
derived ()->step (elt2, elt3)))
return false;
if (!derived ()->can_elide_p (elt3))
return false;
}
return true;
}
template<typename T, typename Shape, typename Derived>
bool
vector_builder<T, Shape, Derived>::try_npatterns (unsigned int npatterns)
{
if (m_nelts_per_pattern == 1)
{
if (repeating_sequence_p (0, encoded_nelts (), npatterns))
{
reshape (npatterns, 1);
return true;
}
if (!encoded_full_vector_p ())
return false;
}
if (m_nelts_per_pattern <= 2)
{
if (repeating_sequence_p (npatterns, encoded_nelts (), npatterns))
{
reshape (npatterns, 2);
return true;
}
if (!encoded_full_vector_p ())
return false;
}
if (m_nelts_per_pattern <= 3)
{
if (stepped_sequence_p (npatterns, encoded_nelts (), npatterns))
{
reshape (npatterns, 3);
return true;
}
return false;
}
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 502, __FUNCTION__));
}
template<typename T, typename Shape, typename Derived>
void
vector_builder<T, Shape, Derived>::finalize ()
{
((void)(!(multiple_p (m_full_nelts, m_npatterns)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h", 513, __FUNCTION__), 0 : 0));
unsigned long const_full_nelts;
if (m_full_nelts.is_constant (&const_full_nelts)
&& const_full_nelts <= encoded_nelts ())
{
m_npatterns = const_full_nelts;
m_nelts_per_pattern = 1;
}
# 534 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
while (m_nelts_per_pattern > 1
&& repeating_sequence_p (encoded_nelts () - m_npatterns * 2,
encoded_nelts (), m_npatterns))
reshape (m_npatterns, m_nelts_per_pattern - 1);
if (pow2p_hwi (m_npatterns))
{
# 582 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
while ((m_npatterns & 1) == 0 && try_npatterns (m_npatterns / 2))
continue;
# 593 "/home/giulianob/gcc_git_gnu/gcc/gcc/vector-builder.h"
if (m_nelts_per_pattern == 1
&& m_full_nelts.is_constant (&const_full_nelts)
&& this->length () >= const_full_nelts
&& (m_npatterns & 3) == 0
&& stepped_sequence_p (m_npatterns / 4, const_full_nelts,
m_npatterns / 4))
{
reshape (m_npatterns / 4, 3);
while ((m_npatterns & 1) == 0 && try_npatterns (m_npatterns / 2))
continue;
}
}
else
for (unsigned int i = 1; i <= m_npatterns / 2; ++i)
if (m_npatterns % i == 0 && try_npatterns (i))
break;
}
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/int-vector-builder.h" 2
template<typename T>
class int_vector_builder : public vector_builder<T, poly_uint64,
int_vector_builder<T> >
{
typedef vector_builder<T, poly_uint64, int_vector_builder> parent;
friend class vector_builder<T, poly_uint64, int_vector_builder>;
public:
int_vector_builder () {}
int_vector_builder (poly_uint64, unsigned int, unsigned int);
using parent::new_vector;
private:
bool equal_p (T, T) const;
bool allow_steps_p () const { return true; }
bool integral_p (T) const { return true; }
T step (T, T) const;
T apply_step (T, unsigned int, T) const;
bool can_elide_p (T) const { return true; }
void note_representative (T *, T) {}
static poly_uint64 shape_nelts (poly_uint64 x) { return x; }
};
template<typename T>
inline
int_vector_builder<T>::int_vector_builder (poly_uint64 full_nelts,
unsigned int npatterns,
unsigned int nelts_per_pattern)
{
new_vector (full_nelts, npatterns, nelts_per_pattern);
}
template<typename T>
inline bool
int_vector_builder<T>::equal_p (T elt1, T elt2) const
{
return (!maybe_ne (elt1, elt2));
}
template<typename T>
inline T
int_vector_builder<T>::step (T elt1, T elt2) const
{
return elt2 - elt1;
}
template<typename T>
inline T
int_vector_builder<T>::apply_step (T base, unsigned int factor, T step) const
{
return base + factor * step;
}
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec-perm-indices.h" 2
typedef int_vector_builder<poly_int64> vec_perm_builder;
# 50 "/home/giulianob/gcc_git_gnu/gcc/gcc/vec-perm-indices.h"
class vec_perm_indices
{
typedef poly_int64 element_type;
public:
vec_perm_indices ();
vec_perm_indices (const vec_perm_builder &, unsigned int, poly_uint64);
void new_vector (const vec_perm_builder &, unsigned int, poly_uint64);
void new_expanded_vector (const vec_perm_indices &, unsigned int);
void rotate_inputs (int delta);
const vec_perm_builder &encoding () const { return m_encoding; }
poly_uint64 length () const { return m_encoding.full_nelts (); }
unsigned int ninputs () const { return m_ninputs; }
poly_uint64 nelts_per_input () const { return m_nelts_per_input; }
poly_uint64 input_nelts () const { return m_ninputs * m_nelts_per_input; }
element_type clamp (element_type) const;
element_type operator[] (unsigned int i) const;
bool series_p (unsigned int, unsigned int, element_type, element_type) const;
bool all_in_range_p (element_type, element_type) const;
bool all_from_input_p (unsigned int) const;
private:
vec_perm_indices (const vec_perm_indices &);
vec_perm_builder m_encoding;
unsigned int m_ninputs;
poly_uint64 m_nelts_per_input;
};
bool tree_to_vec_perm_builder (vec_perm_builder *, tree);
tree vec_perm_indices_to_tree (tree, const vec_perm_indices &);
rtx vec_perm_indices_to_rtx (machine_mode, const vec_perm_indices &);
inline
vec_perm_indices::vec_perm_indices ()
: m_ninputs (0),
m_nelts_per_input (0)
{
}
inline
vec_perm_indices::vec_perm_indices (const vec_perm_builder &elements,
unsigned int ninputs,
poly_uint64 nelts_per_input)
{
new_vector (elements, ninputs, nelts_per_input);
}
inline vec_perm_indices::element_type
vec_perm_indices::clamp (element_type elt) const
{
element_type limit = input_nelts (), elem_within_input;
long input;
if (!can_div_trunc_p (elt, limit, &input, &elem_within_input))
return elt;
if ((!maybe_le (0, elem_within_input)))
return elem_within_input + limit;
return elem_within_input;
}
inline vec_perm_indices::element_type
vec_perm_indices::operator[] (unsigned int i) const
{
return clamp (m_encoding.elt (i));
}
inline bool
vec_perm_indices::all_from_input_p (unsigned int i) const
{
return all_in_range_p (i * m_nelts_per_input, m_nelts_per_input);
}
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h" 2
extern rtx expand_widening_mult (machine_mode, rtx, rtx, rtx, int, optab);
enum expand_operand_type {
EXPAND_FIXED,
EXPAND_OUTPUT,
EXPAND_INPUT,
EXPAND_CONVERT_TO,
EXPAND_CONVERT_FROM,
EXPAND_ADDRESS,
EXPAND_INTEGER
};
class expand_operand {
public:
enum expand_operand_type type : 8;
unsigned int unsigned_p : 1;
unsigned int target : 1;
unsigned int unused : 6;
enum machine_mode mode : 16;
rtx value;
poly_int64 int_value;
};
static inline void
create_expand_operand (class expand_operand *op,
enum expand_operand_type type,
rtx value, machine_mode mode,
bool unsigned_p, poly_int64 int_value = 0)
{
op->type = type;
op->unsigned_p = unsigned_p;
op->target = 0;
op->unused = 0;
op->mode = mode;
op->value = value;
op->int_value = int_value;
}
static inline void
create_fixed_operand (class expand_operand *op, rtx x)
{
create_expand_operand (op, EXPAND_FIXED, x, ((void) 0, E_VOIDmode), false);
}
static inline void
create_output_operand (class expand_operand *op, rtx x,
machine_mode mode)
{
create_expand_operand (op, EXPAND_OUTPUT, x, mode, false);
}
static inline void
create_input_operand (class expand_operand *op, rtx value,
machine_mode mode)
{
create_expand_operand (op, EXPAND_INPUT, value, mode, false);
}
static inline void
create_convert_operand_to (class expand_operand *op, rtx value,
machine_mode mode, bool unsigned_p)
{
create_expand_operand (op, EXPAND_CONVERT_TO, value, mode, unsigned_p);
}
# 139 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h"
static inline void
create_convert_operand_from (class expand_operand *op, rtx value,
machine_mode mode, bool unsigned_p)
{
create_expand_operand (op, EXPAND_CONVERT_FROM, value, mode, unsigned_p);
}
static inline void
create_address_operand (class expand_operand *op, rtx value)
{
create_expand_operand (op, EXPAND_ADDRESS, value, (global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))), false);
}
extern void create_integer_operand (class expand_operand *, poly_int64);
# 165 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h"
enum optab_methods
{
OPTAB_DIRECT,
OPTAB_LIB,
OPTAB_WIDEN,
OPTAB_LIB_WIDEN,
OPTAB_MUST_WIDEN
};
extern rtx expand_widen_pattern_expr (struct separate_ops *, rtx , rtx , rtx,
rtx, int);
extern rtx expand_ternary_op (machine_mode mode, optab ternary_optab,
rtx op0, rtx op1, rtx op2, rtx target,
int unsignedp);
extern rtx simplify_expand_binop (machine_mode mode, optab binoptab,
rtx op0, rtx op1, rtx target, int unsignedp,
enum optab_methods methods);
extern bool force_expand_binop (machine_mode, optab, rtx, rtx, rtx, int,
enum optab_methods);
extern rtx expand_vector_broadcast (machine_mode, rtx);
extern rtx expand_simple_binop (machine_mode, enum rtx_code, rtx,
rtx, rtx, int, enum optab_methods);
extern rtx expand_binop (machine_mode, optab, rtx, rtx, rtx, int,
enum optab_methods);
extern rtx sign_expand_binop (machine_mode, optab, optab, rtx, rtx,
rtx, int, enum optab_methods);
extern int expand_twoval_unop (optab, rtx, rtx, rtx, int);
extern int expand_twoval_binop (optab, rtx, rtx, rtx, rtx, int);
extern bool expand_twoval_binop_libfunc (optab, rtx, rtx, rtx, rtx,
enum rtx_code);
extern rtx expand_simple_unop (machine_mode, enum rtx_code, rtx, rtx,
int);
extern rtx expand_unop (machine_mode, optab, rtx, rtx, int);
extern rtx expand_abs_nojump (machine_mode, rtx, rtx, int);
extern rtx expand_abs (machine_mode, rtx, rtx, int, int);
extern rtx expand_one_cmpl_abs_nojump (machine_mode, rtx, rtx);
extern rtx expand_copysign (rtx, rtx, rtx);
extern bool maybe_emit_unop_insn (enum insn_code, rtx, rtx, enum rtx_code);
extern void emit_unop_insn (enum insn_code, rtx, rtx, enum rtx_code);
extern void emit_libcall_block (rtx_insn *, rtx, rtx, rtx);
enum can_compare_purpose
{
ccp_jump,
ccp_cmov,
ccp_store_flag
};
extern int can_compare_p (enum rtx_code, machine_mode,
enum can_compare_purpose);
extern bool can_vcond_compare_p (enum rtx_code, machine_mode, machine_mode);
extern rtx prepare_operand (enum insn_code, rtx, int, machine_mode,
machine_mode, int);
extern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx,
machine_mode, int, rtx,
profile_probability prob
= profile_probability::uninitialized ());
extern void emit_indirect_jump (rtx);
# 1 "./insn-config.h" 1
# 265 "/home/giulianob/gcc_git_gnu/gcc/gcc/optabs.h" 2
rtx emit_conditional_move (rtx, enum rtx_code, rtx, rtx, machine_mode,
rtx, rtx, machine_mode, int);
rtx emit_conditional_neg_or_complement (rtx, rtx_code, machine_mode, rtx,
rtx, rtx);
rtx emit_conditional_add (rtx, enum rtx_code, rtx, rtx, machine_mode,
rtx, rtx, machine_mode, int);
extern rtx_insn *gen_add2_insn (rtx, rtx);
extern rtx_insn *gen_add3_insn (rtx, rtx, rtx);
extern int have_add2_insn (rtx, rtx);
extern rtx_insn *gen_addptr3_insn (rtx, rtx, rtx);
extern int have_addptr3_insn (rtx, rtx, rtx);
extern rtx_insn *gen_sub2_insn (rtx, rtx);
extern rtx_insn *gen_sub3_insn (rtx, rtx, rtx);
extern int have_sub2_insn (rtx, rtx);
extern rtx_insn *gen_extend_insn (rtx, rtx, machine_mode, machine_mode, int);
extern void expand_float (rtx, rtx, int);
extern void expand_fix (rtx, rtx, int);
extern void expand_fixed_convert (rtx, rtx, int, int);
extern bool expand_sfix_optab (rtx, rtx, convert_optab);
extern int have_insn_for (enum rtx_code, machine_mode);
extern rtx_insn *gen_cond_trap (enum rtx_code, rtx, rtx, rtx);
extern rtx expand_vec_perm_var (machine_mode, rtx, rtx, rtx, rtx);
extern rtx expand_vec_perm_const (machine_mode, rtx, rtx,
const vec_perm_builder &, machine_mode, rtx);
extern rtx expand_vec_cmp_expr (tree, tree, rtx);
extern rtx expand_vec_series_expr (machine_mode, rtx, rtx, rtx);
extern rtx expand_mult_highpart (machine_mode, rtx, rtx, rtx, bool);
extern rtx expand_sync_lock_test_and_set (rtx, rtx, rtx);
extern rtx expand_atomic_test_and_set (rtx, rtx, enum memmodel);
extern rtx expand_atomic_exchange (rtx, rtx, rtx, enum memmodel);
extern bool expand_atomic_compare_and_swap (rtx *, rtx *, rtx, rtx, rtx, bool,
enum memmodel, enum memmodel);
extern void expand_mem_thread_fence (enum memmodel);
extern void expand_mem_signal_fence (enum memmodel);
rtx expand_atomic_load (rtx, rtx, enum memmodel);
rtx expand_atomic_store (rtx, rtx, enum memmodel, bool);
rtx expand_atomic_fetch_op (rtx, rtx, rtx, enum rtx_code, enum memmodel,
bool);
extern bool insn_operand_matches (enum insn_code icode, unsigned int opno,
rtx operand);
extern bool valid_multiword_target_p (rtx);
extern void create_convert_operand_from_type (class expand_operand *op,
rtx value, tree type);
extern bool maybe_legitimize_operands (enum insn_code icode,
unsigned int opno, unsigned int nops,
class expand_operand *ops);
extern rtx_insn *maybe_gen_insn (enum insn_code icode, unsigned int nops,
class expand_operand *ops);
extern bool maybe_expand_insn (enum insn_code icode, unsigned int nops,
class expand_operand *ops);
extern bool maybe_expand_jump_insn (enum insn_code icode, unsigned int nops,
class expand_operand *ops);
extern void expand_insn (enum insn_code icode, unsigned int nops,
class expand_operand *ops);
extern void expand_jump_insn (enum insn_code icode, unsigned int nops,
class expand_operand *ops);
extern enum rtx_code get_rtx_code (enum tree_code tcode, bool unsignedp);
extern rtx vector_compare_rtx (machine_mode cmp_mode, enum tree_code tcode,
tree t_op0, tree t_op1, bool unsignedp,
enum insn_code icode, unsigned int opno);
# 104 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h" 1
# 36 "/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h"
extern int max_regno;
# 58 "/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h"
struct regstat_n_sets_and_refs_t
{
int sets;
int refs;
};
extern struct regstat_n_sets_and_refs_t *regstat_n_sets_and_refs;
static inline int
REG_N_REFS (int regno)
{
return regstat_n_sets_and_refs[regno].refs;
}
static inline int
REG_N_SETS (int regno)
{
return regstat_n_sets_and_refs[regno].sets;
}
extern bool reg_is_parm_p (rtx);
extern void regstat_init_n_sets_and_refs (void);
extern void regstat_free_n_sets_and_refs (void);
extern void regstat_compute_ri (void);
extern void regstat_free_ri (void);
extern bitmap regstat_get_setjmp_crosses (void);
extern void regstat_compute_calls_crossed (void);
extern void regstat_free_calls_crossed (void);
extern void dump_reg_info (FILE *);
struct reg_info_t
{
int freq;
int deaths;
int calls_crossed;
int basic_block;
};
extern struct reg_info_t *reg_info_p;
extern size_t reg_info_p_size;
# 185 "/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h"
extern short *reg_renumber;
extern int caller_save_needed;
# 199 "/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h"
struct target_regs {
unsigned char x_hard_regno_nregs[76][MAX_MACHINE_MODE];
machine_mode x_reg_raw_mode[76];
bool x_have_regs_of_mode[MAX_MACHINE_MODE];
char x_contains_reg_of_mode[((int) LIM_REG_CLASSES)][MAX_MACHINE_MODE];
char x_contains_allocatable_reg_of_mode[((int) LIM_REG_CLASSES)][MAX_MACHINE_MODE];
char x_direct_load[NUM_MACHINE_MODES];
char x_direct_store[NUM_MACHINE_MODES];
bool x_float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];
};
extern struct target_regs default_target_regs;
extern struct target_regs *this_target_regs;
# 254 "/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h"
inline __attribute__ ((always_inline)) unsigned char
hard_regno_nregs (unsigned int regno, machine_mode mode)
{
return this_target_regs->x_hard_regno_nregs[regno][mode];
}
static inline unsigned int
end_hard_regno (machine_mode mode, unsigned int regno)
{
return regno + hard_regno_nregs (regno, mode);
}
static inline void
add_to_hard_reg_set (HARD_REG_SET *regs, machine_mode mode,
unsigned int regno)
{
unsigned int end_regno;
end_regno = end_hard_regno (mode, regno);
do
SET_HARD_REG_BIT (*regs, regno);
while (++regno < end_regno);
}
static inline void
remove_from_hard_reg_set (HARD_REG_SET *regs, machine_mode mode,
unsigned int regno)
{
unsigned int end_regno;
end_regno = end_hard_regno (mode, regno);
do
CLEAR_HARD_REG_BIT (*regs, regno);
while (++regno < end_regno);
}
static inline bool
in_hard_reg_set_p (const_hard_reg_set regs, machine_mode mode,
unsigned int regno)
{
unsigned int end_regno;
((void)(!(((regno) < 76)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/regs.h", 306, __FUNCTION__), 0 : 0));
if (!TEST_HARD_REG_BIT (regs, regno))
return false;
end_regno = end_hard_regno (mode, regno);
if (!((end_regno - 1) < 76))
return false;
while (++regno < end_regno)
if (!TEST_HARD_REG_BIT (regs, regno))
return false;
return true;
}
static inline bool
overlaps_hard_reg_set_p (const_hard_reg_set regs, machine_mode mode,
unsigned int regno)
{
unsigned int end_regno;
if (TEST_HARD_REG_BIT (regs, regno))
return true;
end_regno = end_hard_regno (mode, regno);
while (++regno < end_regno)
if (TEST_HARD_REG_BIT (regs, regno))
return true;
return false;
}
static inline void
add_range_to_hard_reg_set (HARD_REG_SET *regs, unsigned int regno,
int nregs)
{
while (nregs-- > 0)
SET_HARD_REG_BIT (*regs, regno + nregs);
}
static inline void
remove_range_from_hard_reg_set (HARD_REG_SET *regs, unsigned int regno,
int nregs)
{
while (nregs-- > 0)
CLEAR_HARD_REG_BIT (*regs, regno + nregs);
}
static inline bool
range_overlaps_hard_reg_set_p (const_hard_reg_set set, unsigned regno,
int nregs)
{
while (nregs-- > 0)
if (TEST_HARD_REG_BIT (set, regno + nregs))
return true;
return false;
}
static inline bool
range_in_hard_reg_set_p (const_hard_reg_set set, unsigned regno, int nregs)
{
while (nregs-- > 0)
if (!TEST_HARD_REG_BIT (set, regno + nregs))
return false;
return true;
}
# 105 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h"
class temp_slot;
typedef class temp_slot *temp_slot_p;
class predefined_function_abi;
struct incoming_args {
poly_int64_pod pops_args;
poly_int64_pod size;
int pretend_args_size;
rtx arg_offset_rtx;
CUMULATIVE_ARGS info;
rtx internal_arg_pointer;
};
struct rtl_data {
void init_stack_alignment ();
struct expr_status expr;
struct emit_status emit;
struct varasm_status varasm;
struct incoming_args args;
struct function_subsections subsections;
struct rtl_eh eh;
const predefined_function_abi * abi;
poly_int64_pod outgoing_args_size;
rtx return_rtx;
struct initial_value_struct *hard_reg_initial_vals;
tree stack_protect_guard;
tree stack_protect_guard_decl;
rtx_insn_list *x_nonlocal_goto_handler_labels;
rtx_code_label *x_return_label;
rtx_code_label *x_naked_return_label;
vec<rtx, va_gc> *x_stack_slot_list;
class frame_space *frame_space_list;
rtx_note *x_stack_check_probe_note;
rtx x_arg_pointer_save_area;
rtx drap_reg;
poly_int64_pod x_frame_offset;
rtx_insn *x_parm_birth_insn;
vec<temp_slot_p, va_gc> *x_used_temp_slots;
class temp_slot *x_avail_temp_slots;
int x_temp_slot_level;
unsigned int stack_alignment_needed;
unsigned int preferred_stack_boundary;
unsigned int parm_stack_boundary;
unsigned int max_used_stack_slot_alignment;
# 174 "/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h"
unsigned int stack_alignment_estimated;
unsigned short patch_area_size;
unsigned short patch_area_entry;
bool accesses_prior_frames;
bool calls_eh_return;
bool saves_all_registers;
bool has_nonlocal_goto;
bool has_asm_statement;
bool all_throwers_are_sibcalls;
bool limit_stack;
bool profile;
bool uses_const_pool;
bool uses_pic_offset_table;
bool uses_eh_lsda;
bool tail_call_emit;
bool arg_pointer_save_area_init;
bool frame_pointer_needed;
bool maybe_hot_insn_p;
bool stack_realign_needed;
bool stack_realign_tried;
bool need_drap;
bool stack_realign_processed;
bool stack_realign_finalized;
bool dbr_scheduled_p;
bool nothrow;
bool shrink_wrapped;
bool shrink_wrapped_separate;
bool sp_is_unchanging;
bool is_leaf;
bool uses_only_leaf_regs;
bool has_bb_partition;
bool bb_reorder_complete;
HARD_REG_SET asm_clobbers;
int max_insn_address;
};
# 329 "/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h"
extern struct rtl_data x_rtl;
bool mem_attrs_eq_p (const class mem_attrs *, const class mem_attrs *);
extern void set_mem_alias_set (rtx, alias_set_type);
extern void set_mem_align (rtx, unsigned int);
extern void set_mem_addr_space (rtx, addr_space_t);
extern void set_mem_expr (rtx, tree);
extern void set_mem_offset (rtx, poly_int64);
extern void clear_mem_offset (rtx);
extern void set_mem_size (rtx, poly_int64);
extern void clear_mem_size (rtx);
extern void set_mem_attrs_for_spill (rtx);
extern tree get_spill_slot_decl (bool);
extern rtx replace_equiv_address (rtx, rtx, bool = false);
extern rtx replace_equiv_address_nv (rtx, rtx, bool = false);
extern rtx gen_blockage (void);
extern rtvec gen_rtvec (int, ...);
extern rtx copy_insn_1 (rtx);
extern rtx copy_insn (rtx);
extern rtx_insn *copy_delay_slot_insn (rtx_insn *);
extern rtx gen_int_mode (poly_int64, machine_mode);
extern rtx_insn *emit_copy_of_insn_after (rtx_insn *, rtx_insn *);
extern void set_reg_attrs_from_value (rtx, rtx);
extern void set_reg_attrs_for_parm (rtx, rtx);
extern void set_reg_attrs_for_decl_rtl (tree t, rtx x);
extern void adjust_reg_mode (rtx, machine_mode);
extern int mem_expr_equal_p (const_tree, const_tree);
extern rtx gen_int_shift_amount (machine_mode, poly_int64);
extern bool need_atomic_barrier_p (enum memmodel, bool);
static inline struct sequence_stack *
get_current_sequence (void)
{
return &(&x_rtl)->emit.seq;
}
static inline struct sequence_stack *
get_topmost_sequence (void)
{
struct sequence_stack *seq, *top;
seq = get_current_sequence ();
do
{
top = seq;
seq = seq->next;
} while (seq);
return top;
}
static inline rtx_insn *
get_insns (void)
{
return get_current_sequence ()->first;
}
static inline void
set_first_insn (rtx_insn *insn)
{
((void)(!(!insn || !PREV_INSN (insn)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h", 429, __FUNCTION__), 0 : 0));
get_current_sequence ()->first = insn;
}
static inline rtx_insn *
get_last_insn (void)
{
return get_current_sequence ()->last;
}
static inline void
set_last_insn (rtx_insn *insn)
{
((void)(!(!insn || !NEXT_INSN (insn)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h", 446, __FUNCTION__), 0 : 0));
get_current_sequence ()->last = insn;
}
static inline int
get_max_uid (void)
{
return (&x_rtl)->emit.x_cur_insn_uid;
}
extern bool valid_for_const_vector_p (machine_mode, rtx);
extern rtx gen_const_vec_duplicate (machine_mode, rtx);
extern rtx gen_vec_duplicate (machine_mode, rtx);
extern rtx gen_const_vec_series (machine_mode, rtx, rtx);
extern rtx gen_vec_series (machine_mode, rtx, rtx);
extern void set_decl_incoming_rtl (tree, rtx, bool);
extern rtx change_address (rtx, machine_mode, rtx);
# 508 "/home/giulianob/gcc_git_gnu/gcc/gcc/emit-rtl.h"
extern rtx adjust_address_1 (rtx, machine_mode, poly_int64, int, int,
int, poly_int64);
extern rtx adjust_automodify_address_1 (rtx, machine_mode, rtx,
poly_int64, int);
extern rtx offset_address (rtx, rtx, unsigned long);
extern void set_mem_attributes (rtx, tree, int);
extern void set_mem_attributes_minus_bitpos (rtx, tree, int, poly_int64);
extern int get_mem_align_offset (rtx, unsigned int);
extern rtx widen_memory_access (rtx, machine_mode, poly_int64);
extern void maybe_set_max_label_num (rtx_code_label *x);
# 106 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
extern void init_final (const char *);
extern void app_enable (void);
extern void app_disable (void);
extern int dbr_sequence_length (void);
extern void init_insn_lengths (void);
extern int get_attr_length (rtx_insn *);
extern int get_attr_min_length (rtx_insn *);
extern void shorten_branches (rtx_insn *);
const char *get_some_local_dynamic_name ();
extern void final_start_function (rtx_insn *, FILE *, int);
extern void final_end_function (void);
extern void final (rtx_insn *, FILE *, int);
extern rtx_insn *final_scan_insn (rtx_insn *, FILE *, int, int, int *);
extern rtx alter_subreg (rtx *, bool);
extern void output_operand (rtx, int);
extern void output_operand_lossage (const char *, ...) __attribute__ ((__format__ (__printf__, 1, 2))) __attribute__ ((__nonnull__ (1)));
extern void output_asm_insn (const char *, rtx *);
extern int insn_current_reference_address (rtx_insn *);
extern align_flags label_to_alignment (rtx);
extern void output_asm_label (rtx);
extern void mark_symbol_refs_as_used (rtx);
extern void output_address (machine_mode, rtx);
extern void output_addr_const (FILE *, rtx);
# 124 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
extern void fprint_whex (FILE *, unsigned long);
extern void fprint_ul (FILE *, unsigned long);
extern int sprint_ul (char *, unsigned long);
extern void asm_fprintf (FILE *file, const char *p, ...)
__attribute__ ((__format__ (__asm_fprintf__, 2, 3))) __attribute__ ((__nonnull__ (2)));
extern int leaf_function_p (void);
extern int final_forward_branch_p (rtx_insn *);
extern int only_leaf_regs_used (void);
extern void leaf_renumber_regs_insn (rtx);
extern const char *get_insn_template (int, rtx_insn *);
extern void weak_finish (void);
# 162 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
extern int decode_reg_name (const char *);
extern int decode_reg_name_and_count (const char *, int *);
extern void do_assemble_alias (tree, tree);
extern void do_assemble_symver (tree, tree);
extern void default_assemble_visibility (tree, int);
extern void assemble_asm (tree);
extern const char *get_fnname_from_decl (tree);
extern void assemble_start_function (tree, const char *);
extern void assemble_end_function (tree, const char *);
# 200 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
extern void assemble_variable (tree, int, int, int);
extern void assemble_vtv_preinit_initializer (tree);
extern void assemble_undefined_decl (tree);
extern void align_variable (tree decl, bool dont_output_data);
extern void assemble_external (tree);
extern void assemble_zeros (unsigned long);
extern void assemble_align (unsigned int);
extern void assemble_string (const char *, int);
extern void assemble_external_libcall (rtx);
extern void assemble_label (FILE *, const char *);
extern void assemble_name_raw (FILE *, const char *);
extern const char *assemble_name_resolve (const char *);
extern void assemble_name (FILE *, const char *);
# 259 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
extern const char *integer_asm_op (int, int);
extern void assemble_integer_with_op (const char *, rtx);
extern bool default_assemble_integer (rtx, unsigned int, int);
extern bool assemble_integer (rtx, unsigned, unsigned, int);
extern section *get_named_text_section (tree, const char *, const char *);
# 287 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
extern void assemble_real (struct real_value, scalar_float_mode, unsigned,
bool = false);
extern void assemble_addr_to_section (rtx, section *);
extern bool constant_pool_empty_p (void);
extern rtx_insn *peephole (rtx_insn *);
extern void output_shared_constant_pool (void);
extern void output_object_blocks (void);
extern void output_quoted_string (FILE *, const char *);
extern rtx_sequence *final_sequence;
extern FILE *asm_out_file;
extern const char *first_global_object_name;
extern const char *weak_global_object_name;
extern rtx current_insn_predicate;
extern rtx_insn *current_output_insn;
extern const rtx_insn *this_is_asm_operands;
extern int size_directive_output;
extern tree last_assemble_variable_decl;
extern bool first_function_block_is_cold;
extern bool decl_readonly_section (const_tree, int);
extern int compute_reloc_for_constant (tree);
extern const char *user_label_prefix;
extern void default_function_pro_epilogue (FILE *);
extern void default_function_switched_text_sections (FILE *, tree, bool);
extern void no_asm_to_stream (FILE *);
# 402 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
enum section_category
{
SECCAT_TEXT,
SECCAT_RODATA,
SECCAT_RODATA_MERGE_STR,
SECCAT_RODATA_MERGE_STR_INIT,
SECCAT_RODATA_MERGE_CONST,
SECCAT_SRODATA,
SECCAT_DATA,
# 423 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
SECCAT_DATA_REL,
SECCAT_DATA_REL_LOCAL,
SECCAT_DATA_REL_RO,
SECCAT_DATA_REL_RO_LOCAL,
SECCAT_SDATA,
SECCAT_TDATA,
SECCAT_BSS,
SECCAT_SBSS,
SECCAT_TBSS
};
struct section_common {
unsigned int flags;
};
struct named_section {
struct section_common common;
const char *name;
tree decl;
};
typedef void (*unnamed_section_callback) (const void *);
struct unnamed_section {
struct section_common common;
unnamed_section_callback callback;
const void * data;
section *next;
};
# 480 "/home/giulianob/gcc_git_gnu/gcc/gcc/output.h"
typedef bool (*noswitch_section_callback) (tree decl, const char *name,
unsigned long size,
unsigned long rounded);
struct noswitch_section {
struct section_common common;
noswitch_section_callback callback;
};
union section {
struct section_common common;
struct named_section named;
struct unnamed_section unnamed;
struct noswitch_section noswitch;
};
struct object_block;
extern section *text_section;
extern section *data_section;
extern section *readonly_data_section;
extern section *sdata_section;
extern section *ctors_section;
extern section *dtors_section;
extern section *bss_section;
extern section *sbss_section;
extern section *exception_section;
extern section *eh_frame_section;
extern section *tls_comm_section;
extern section *comm_section;
extern section *lcomm_section;
extern section *bss_noswitch_section;
extern section *in_section;
extern bool in_cold_section_p;
extern section *get_unnamed_section (unsigned int, void (*) (const void *),
const void *);
extern section *get_section (const char *, unsigned int, tree);
extern section *get_named_section (tree, const char *, int);
extern section *get_variable_section (tree, bool);
extern void place_block_symbol (rtx);
extern rtx get_section_anchor (struct object_block *, long,
enum tls_model);
extern section *mergeable_constant_section (machine_mode,
unsigned long,
unsigned int);
extern section *function_section (tree);
extern section *unlikely_text_section (void);
extern section *current_function_section (void);
extern void switch_to_other_text_partition (void);
extern section *get_cdtor_priority_section (int, bool);
extern bool unlikely_text_section_p (section *);
extern void switch_to_section (section *);
extern void output_section_asm_op (const void *);
extern void record_tm_clone_pair (tree, tree);
extern void finish_tm_clone_pairs (void);
extern tree get_tm_clone_pair (tree);
extern void default_asm_output_source_filename (FILE *, const char *);
extern void output_file_directive (FILE *, const char *);
extern unsigned int default_section_type_flags (tree, const char *, int);
extern bool have_global_bss_p (void);
extern bool bss_initializer_p (const_tree, bool = false);
extern void default_no_named_section (const char *, unsigned int, tree);
extern void default_elf_asm_named_section (const char *, unsigned int, tree);
extern enum section_category categorize_decl_for_section (const_tree, int);
extern void default_coff_asm_named_section (const char *, unsigned int, tree);
extern void default_pe_asm_named_section (const char *, unsigned int, tree);
extern void default_named_section_asm_out_destructor (rtx, int);
extern void default_dtor_section_asm_out_destructor (rtx, int);
extern void default_named_section_asm_out_constructor (rtx, int);
extern void default_ctor_section_asm_out_constructor (rtx, int);
extern section *default_select_section (tree, int, unsigned long);
extern section *default_elf_select_section (tree, int, unsigned long);
extern void default_unique_section (tree, int);
extern section *default_function_rodata_section (tree);
extern section *default_no_function_rodata_section (tree);
extern section *default_clone_table_section (void);
extern section *default_select_rtx_section (machine_mode, rtx,
unsigned long);
extern section *default_elf_select_rtx_section (machine_mode, rtx,
unsigned long);
extern void default_encode_section_info (tree, rtx, int);
extern const char *default_strip_name_encoding (const char *);
extern void default_asm_output_anchor (rtx);
extern bool default_use_anchors_for_symbol_p (const_rtx);
extern bool default_binds_local_p (const_tree);
extern bool default_binds_local_p_1 (const_tree, int);
extern bool default_binds_local_p_2 (const_tree);
extern bool default_binds_local_p_3 (const_tree, bool, bool, bool, bool);
extern void default_globalize_label (FILE *, const char *);
extern void default_globalize_decl_name (FILE *, tree);
extern void default_emit_unwind_label (FILE *, tree, int, int);
extern void default_emit_except_table_label (FILE *);
extern void default_generate_internal_label (char *, const char *,
unsigned long);
extern void default_internal_label (FILE *, const char *, unsigned long);
extern void default_asm_declare_constant_name (FILE *, const char *,
const_tree, long);
extern void default_file_start (void);
extern void file_end_indicate_exec_stack (void);
extern void file_end_indicate_split_stack (void);
extern void default_elf_asm_output_external (FILE *file, tree,
const char *);
extern void default_elf_asm_output_limited_string (FILE *, const char *);
extern void default_elf_asm_output_ascii (FILE *, const char *, unsigned int);
extern void default_elf_internal_label (FILE *, const char *, unsigned long);
extern void default_elf_init_array_asm_out_constructor (rtx, int);
extern void default_elf_fini_array_asm_out_destructor (rtx, int);
extern int maybe_assemble_visibility (tree);
extern int default_address_cost (rtx, machine_mode, addr_space_t, bool);
extern void output_stack_usage (void);
# 107 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/expr.h" 1
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/expr.h"
enum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM, EXPAND_SUM,
EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE,
EXPAND_MEMORY};
# 49 "/home/giulianob/gcc_git_gnu/gcc/gcc/expr.h"
typedef struct separate_ops
{
enum tree_code code;
location_t location;
tree type;
tree op0, op1, op2;
} *sepops;
extern void init_expr_target (void);
extern void init_expr (void);
extern void convert_move (rtx, rtx, int);
extern rtx convert_to_mode (machine_mode, rtx, int);
extern rtx convert_modes (machine_mode, machine_mode, rtx, int);
extern rtx emit_block_op_via_libcall (enum built_in_function, rtx, rtx, rtx,
bool);
static inline rtx
emit_block_copy_via_libcall (rtx dst, rtx src, rtx size, bool tailcall = false)
{
return emit_block_op_via_libcall (BUILT_IN_MEMCPY, dst, src, size, tailcall);
}
static inline rtx
emit_block_move_via_libcall (rtx dst, rtx src, rtx size, bool tailcall = false)
{
return emit_block_op_via_libcall (BUILT_IN_MEMMOVE, dst, src, size, tailcall);
}
static inline rtx
emit_block_comp_via_libcall (rtx dst, rtx src, rtx size, bool tailcall = false)
{
return emit_block_op_via_libcall (BUILT_IN_MEMCMP, dst, src, size, tailcall);
}
enum block_op_methods
{
BLOCK_OP_NORMAL,
BLOCK_OP_NO_LIBCALL,
BLOCK_OP_CALL_PARM,
BLOCK_OP_TAILCALL,
BLOCK_OP_NO_LIBCALL_RET
};
typedef rtx (*by_pieces_constfn) (void *, long, scalar_int_mode);
extern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods);
extern rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods,
unsigned int, long,
unsigned long,
unsigned long,
unsigned long,
bool bail_out_libcall = false,
bool *is_move_done = nullptr,
bool might_overlap = false);
extern rtx emit_block_cmp_hints (rtx, rtx, rtx, tree, rtx, bool,
by_pieces_constfn, void *);
extern bool emit_storent_insn (rtx to, rtx from);
extern void move_block_to_reg (int, rtx, int, machine_mode);
extern void move_block_from_reg (int, rtx, int);
extern rtx gen_group_rtx (rtx);
extern void emit_group_load (rtx, rtx, tree, poly_int64);
extern rtx emit_group_load_into_temps (rtx, rtx, tree, poly_int64);
extern void emit_group_move (rtx, rtx);
extern rtx emit_group_move_into_temps (rtx);
extern void emit_group_store (rtx, rtx, tree, poly_int64);
extern rtx maybe_emit_group_store (rtx, tree);
extern void use_reg_mode (rtx *, rtx, machine_mode);
extern void clobber_reg_mode (rtx *, rtx, machine_mode);
extern rtx copy_blkmode_to_reg (machine_mode, tree);
static inline void
use_reg (rtx *fusage, rtx reg)
{
use_reg_mode (fusage, reg, ((void) 0, E_VOIDmode));
}
static inline void
clobber_reg (rtx *fusage, rtx reg)
{
clobber_reg_mode (fusage, reg, ((void) 0, E_VOIDmode));
}
extern void use_regs (rtx *, int, int);
extern void use_group_regs (rtx *, rtx);
extern rtx expand_cmpstrn_or_cmpmem (insn_code, rtx, rtx, rtx, tree, rtx,
long);
extern rtx clear_storage (rtx, rtx, enum block_op_methods);
extern rtx clear_storage_hints (rtx, rtx, enum block_op_methods,
unsigned int, long,
unsigned long,
unsigned long,
unsigned long);
extern rtx set_storage_via_libcall (rtx, rtx, rtx, bool = false);
extern bool set_storage_via_setmem (rtx, rtx, rtx, unsigned int,
unsigned int, long,
unsigned long,
unsigned long,
unsigned long);
# 214 "/home/giulianob/gcc_git_gnu/gcc/gcc/expr.h"
extern int can_store_by_pieces (unsigned long,
by_pieces_constfn,
void *, unsigned int, bool);
extern rtx store_by_pieces (rtx, unsigned long, by_pieces_constfn,
void *, unsigned int, bool, memop_ret);
extern rtx_insn *emit_move_insn (rtx, rtx);
extern rtx_insn *gen_move_insn (rtx, rtx);
extern rtx_insn *emit_move_insn_1 (rtx, rtx);
extern rtx_insn *emit_move_complex_push (machine_mode, rtx, rtx);
extern rtx_insn *emit_move_complex_parts (rtx, rtx);
extern rtx read_complex_part (rtx, bool);
extern void write_complex_part (rtx, rtx, bool);
extern rtx read_complex_part (rtx, bool);
extern rtx emit_move_resolve_push (machine_mode, rtx);
extern rtx push_block (rtx, poly_int64, int);
extern bool emit_push_insn (rtx, machine_mode, tree, rtx, unsigned int,
int, rtx, poly_int64, rtx, rtx, int, rtx, bool);
extern void get_bit_range (poly_uint64_pod *, poly_uint64_pod *, tree,
poly_int64_pod *, tree *);
extern void expand_assignment (tree, tree, bool);
extern rtx store_expr (tree, rtx, int, bool, bool);
extern rtx force_operand (rtx, rtx);
extern rtx expand_expr_real (tree, rtx, machine_mode,
enum expand_modifier, rtx *, bool);
extern rtx expand_expr_real_1 (tree, rtx, machine_mode,
enum expand_modifier, rtx *, bool);
extern rtx expand_expr_real_2 (sepops, rtx, machine_mode,
enum expand_modifier);
static inline rtx
expand_expr (tree exp, rtx target, machine_mode mode,
enum expand_modifier modifier)
{
return expand_expr_real (exp, target, mode, modifier, nullptr, false);
}
static inline rtx
expand_normal (tree exp)
{
return expand_expr_real (exp, (rtx) 0, ((void) 0, E_VOIDmode), EXPAND_NORMAL, nullptr, false);
}
extern tree string_constant (tree, tree *, tree *, tree *);
extern tree byte_representation (tree, tree *, tree *, tree *);
extern enum tree_code maybe_optimize_mod_cmp (enum tree_code, tree *, tree *);
extern int try_casesi (tree, tree, tree, tree, rtx, rtx, rtx, profile_probability);
extern int try_tablejump (tree, tree, tree, tree, rtx, rtx, profile_probability);
extern int safe_from_p (const_rtx, tree, int);
rtx get_personality_function (tree);
extern bool can_move_by_pieces (unsigned long, unsigned int);
extern unsigned long highest_pow2_factor (const_tree);
extern bool categorize_ctor_elements (const_tree, long *,
long *, long *,
bool *);
extern void expand_operands (tree, tree, rtx, rtx*, rtx*,
enum expand_modifier);
extern rtx expr_size (tree);
# 108 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-pass.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-pass.h"
struct function;
enum opt_pass_type
{
GIMPLE_PASS,
RTL_PASS,
SIMPLE_IPA_PASS,
IPA_PASS
};
struct pass_data
{
enum opt_pass_type type;
const char *name;
optgroup_flags_t optinfo_flags;
timevar_id_t tv_id;
unsigned int properties_required;
unsigned int properties_provided;
unsigned int properties_destroyed;
unsigned int todo_flags_start;
unsigned int todo_flags_finish;
};
namespace gcc
{
class context;
}
class opt_pass : public pass_data
{
public:
virtual ~opt_pass () { }
# 85 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-pass.h"
virtual opt_pass *clone ();
virtual void set_pass_param (unsigned int, bool);
virtual bool gate (function *fun);
virtual unsigned int execute (function *fun);
protected:
opt_pass (const pass_data&, gcc::context *);
public:
opt_pass *sub;
opt_pass *next;
int static_pass_number;
protected:
gcc::context *m_ctxt;
};
class gimple_opt_pass : public opt_pass
{
protected:
gimple_opt_pass (const pass_data& data, gcc::context *ctxt)
: opt_pass (data, ctxt)
{
}
};
class rtl_opt_pass : public opt_pass
{
protected:
rtl_opt_pass (const pass_data& data, gcc::context *ctxt)
: opt_pass (data, ctxt)
{
}
};
struct varpool_node;
struct cgraph_node;
struct lto_symtab_encoder_d;
class ipa_opt_pass_d : public opt_pass
{
public:
void (*generate_summary) (void);
void (*write_summary) (void);
void (*read_summary) (void);
void (*write_optimization_summary) (void);
void (*read_optimization_summary) (void);
void (*stmt_fixup) (struct cgraph_node *, gimple **);
unsigned int function_transform_todo_flags_start;
unsigned int (*function_transform) (struct cgraph_node *);
void (*variable_transform) (varpool_node *);
protected:
ipa_opt_pass_d (const pass_data& data, gcc::context *ctxt,
void (*generate_summary) (void),
void (*write_summary) (void),
void (*read_summary) (void),
void (*write_optimization_summary) (void),
void (*read_optimization_summary) (void),
void (*stmt_fixup) (struct cgraph_node *, gimple **),
unsigned int function_transform_todo_flags_start,
unsigned int (*function_transform) (struct cgraph_node *),
void (*variable_transform) (varpool_node *))
: opt_pass (data, ctxt),
generate_summary (generate_summary),
write_summary (write_summary),
read_summary (read_summary),
write_optimization_summary (write_optimization_summary),
read_optimization_summary (read_optimization_summary),
stmt_fixup (stmt_fixup),
function_transform_todo_flags_start (function_transform_todo_flags_start),
function_transform (function_transform),
variable_transform (variable_transform)
{
}
};
class simple_ipa_opt_pass : public opt_pass
{
protected:
simple_ipa_opt_pass (const pass_data& data, gcc::context *ctxt)
: opt_pass (data, ctxt)
{
}
};
# 316 "/home/giulianob/gcc_git_gnu/gcc/gcc/tree-pass.h"
enum pass_positioning_ops
{
PASS_POS_INSERT_AFTER,
PASS_POS_INSERT_BEFORE,
PASS_POS_REPLACE
};
struct register_pass_info
{
opt_pass *pass;
const char *reference_pass_name;
int ref_pass_instance_number;
enum pass_positioning_ops pos_op;
};
extern void register_pass (register_pass_info *);
extern void register_pass (opt_pass* pass, pass_positioning_ops pos,
const char* ref_pass_name, int ref_pass_inst_number);
extern gimple_opt_pass *make_pass_asan (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_asan_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tsan (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tsan_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sancov (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sancov_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_cf (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_refactor_eh (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_eh (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_eh_dispatch (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_resx (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_build_cfg (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_early_tree_profile (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_cleanup_eh (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sra (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sra_early (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tail_recursion (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tail_calls (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_fix_loops (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tree_loop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tree_no_loop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tree_loop_init (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_loop_versioning (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lim (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_linterchange (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tree_unswitch (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_loop_split (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_loop_jam (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_predcom (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_iv_canon (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_scev_cprop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_empty_loop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_graphite (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_graphite_transforms (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_if_conversion (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_loop_distribution (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_vectorize (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_simduid_cleanup (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_slp_vectorize (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_complete_unroll (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_complete_unrolli (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_parallelize_loops (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_loop_prefetch (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_iv_optimize (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tree_loop_done (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_ch (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_ch_vect (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_ccp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_split_paths (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_build_ssa (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_build_alias (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_build_ealias (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_dominator (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_dce (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_cd_dce (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_call_cdce (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_merge_phi (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_thread_jumps (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_early_thread_jumps (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_split_crit_edges (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_laddress (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_pre (gcc::context *ctxt);
extern unsigned int tail_merge_optimize (unsigned int);
extern gimple_opt_pass *make_pass_profile (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_strip_predict_hints (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_complex_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_complex (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_switch (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_switch_O0 (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vector (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vector_ssa (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_omp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_diagnose_omp_blocks (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_expand_omp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_expand_omp_ssa (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_omp_target_link (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_oacc_device_lower (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_omp_device_lower (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_object_sizes (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_warn_printf (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_strlen (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_fold_builtins (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_post_ipa_warn (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_stdarg (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_early_warn_uninitialized (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_late_warn_uninitialized (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_cse_reciprocals (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_cse_sincos (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_optimize_bswap (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_store_merging (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_optimize_widening_mul (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_warn_function_return (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_warn_function_noreturn (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_cselim (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_phiopt (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_forwprop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_phiprop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tree_ifcombine (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_dse (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_nrv (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_rename_ssa_copies (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sink_code (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_fre (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_check_data_deps (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_copy_prop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_isolate_erroneous_paths (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_early_vrp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_vrp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_uncprop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_return_slot (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_reassoc (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_rebuild_cgraph_edges (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_remove_cgraph_callee_edges (gcc::context
*ctxt);
extern gimple_opt_pass *make_pass_build_cgraph_edges (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_local_pure_const (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_nothrow (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tracer (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_warn_restrict (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_warn_unused_result (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_diagnose_tm_blocks (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_tm (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tm_init (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tm_mark (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tm_memopt (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_tm_edges (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_split_functions (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_feedback_split_functions (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_strength_reduction (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_vtable_verify (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_ubsan (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sanopt (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_oacc_kernels (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_oacc (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_oacc_kernels (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_warn_nonnull_compare (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_sprintf_length (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_walloca (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_coroutine_lower_builtins (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_coroutine_early_expand_ifns (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_adjust_alignment (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_lower_emutls (gcc::context *ctxt);
extern simple_ipa_opt_pass
*make_pass_ipa_function_and_variable_visibility (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_tree_profile (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_auto_profile (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_build_ssa_passes (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_local_optimization_passes (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_remove_symbols (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_analyzer (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_whole_program_visibility (gcc::context
*ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_increase_alignment (gcc::context
*ctxt);
extern ipa_opt_pass_d *make_pass_ipa_fn_summary (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_inline (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_free_lang_data (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_free_fn_summary (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_cp (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_sra (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_icf (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_devirt (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_odr (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_reference (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_pure_const (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_pta (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_ipa_tm (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_target_clone (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_dispatcher_calls (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_omp_simd_clone (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_profile (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_cdtor_merge (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_single_use (gcc::context *ctxt);
extern ipa_opt_pass_d *make_pass_ipa_comdats (gcc::context *ctxt);
extern simple_ipa_opt_pass *make_pass_materialize_all_clones (gcc::context *
ctxt);
extern gimple_opt_pass *make_pass_cleanup_cfg_post_optimizing (gcc::context
*ctxt);
extern gimple_opt_pass *make_pass_fixup_cfg (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_backprop (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_expand (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_instantiate_virtual_regs (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_fwprop (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_fwprop_addr (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_jump (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_jump2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_lower_subreg (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_cse (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_fast_rtl_dce (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_ud_rtl_dce (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_dce (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_dse1 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_dse2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_dse3 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_cprop (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_pre (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_hoist (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_store_motion (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_cse_after_global_opts (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_ifcvt (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_into_cfg_layout_mode (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_outof_cfg_layout_mode (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_loop2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_loop_init (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_move_loop_invariants (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_unroll_loops (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_doloop (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_loop_done (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_lower_subreg2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_web (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_cse2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_df_initialize_opt (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_df_initialize_no_opt (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_reginfo_init (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_inc_dec (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_stack_ptr_mod (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_initialize_regs (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_combine (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_if_after_combine (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_jump_after_combine (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_ree (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_partition_blocks (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_match_asm_constraints (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_split_all_insns (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_fast_rtl_byte_dce (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_lower_subreg3 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_mode_switching (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_sms (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_sched (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_live_range_shrinkage (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_early_remat (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_ira (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_reload (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_clean_state (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_branch_prob (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_value_profile_transformations (gcc::context
*ctxt);
extern rtl_opt_pass *make_pass_postreload_cse (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_gcse2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_split_after_reload (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_thread_prologue_and_epilogue (gcc::context
*ctxt);
extern rtl_opt_pass *make_pass_stack_adjustments (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_sched_fusion (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_peephole2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_if_after_reload (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_regrename (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_cprop_hardreg (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_reorder_blocks (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_leaf_regs (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_split_before_sched2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_compare_elim_after_reload (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_sched2 (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_stack_regs (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_stack_regs_run (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_df_finish (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_compute_alignments (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_duplicate_computed_gotos (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_variable_tracking (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_free_cfg (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_machine_reorg (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_cleanup_barriers (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_delay_slots (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_split_for_shorten_branches (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_split_before_regstack (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_convert_to_eh_region_ranges (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_shorten_branches (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_set_nothrow_function_flags (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_dwarf2_frame (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_final (gcc::context *ctxt);
extern rtl_opt_pass *make_pass_rtl_seqabstr (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_release_ssa_names (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_early_inline (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_local_fn_summary (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_update_address_taken (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_convert_switch (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_lower_vaarg (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_gimple_isel (gcc::context *ctxt);
extern opt_pass *current_pass;
extern bool execute_one_pass (opt_pass *);
extern void execute_pass_list (function *, opt_pass *);
extern void execute_ipa_pass_list (opt_pass *);
extern void execute_ipa_summary_passes (ipa_opt_pass_d *);
extern void execute_all_ipa_transforms (bool);
extern void execute_all_ipa_stmt_fixups (struct cgraph_node *, gimple **);
extern bool pass_init_dump_file (opt_pass *);
extern void pass_fini_dump_file (opt_pass *);
extern void emergency_dump_function (void);
extern void print_current_pass (FILE *);
extern void debug_pass (void);
extern void ipa_write_summaries (void);
extern void ipa_write_optimization_summaries (struct lto_symtab_encoder_d *);
extern void ipa_read_summaries (void);
extern void ipa_read_optimization_summaries (void);
extern void register_one_dump_file (opt_pass *);
extern bool function_called_by_processed_nodes_p (void);
extern void do_per_function_toporder (void (*) (function *, void *), void *);
extern void disable_pass (const char *);
extern void enable_pass (const char *);
extern void dump_passes (void);
# 109 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfgrtl.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfgrtl.h"
extern void delete_insn (rtx_insn *);
extern bool delete_insn_and_edges (rtx_insn *);
extern void delete_insn_chain (rtx, rtx_insn *, bool);
extern basic_block create_basic_block_structure (rtx_insn *, rtx_insn *,
rtx_note *, basic_block);
extern void compute_bb_for_insn (void);
extern unsigned int free_bb_for_insn (void);
extern rtx_insn *entry_of_function (void);
extern void update_bb_for_insn (basic_block);
extern bool contains_no_active_insn_p (const_basic_block);
extern bool forwarder_block_p (const_basic_block);
extern bool can_fallthru (basic_block, basic_block);
extern rtx_note *bb_note (basic_block);
extern rtx_code_label *block_label (basic_block);
extern edge try_redirect_by_replacing_jump (edge, basic_block, bool);
extern void emit_barrier_after_bb (basic_block bb);
extern basic_block force_nonfallthru_and_redirect (edge, basic_block, rtx);
extern void insert_insn_on_edge (rtx, edge);
extern void commit_one_edge_insertion (edge e);
extern void commit_edge_insertions (void);
extern void print_rtl_with_bb (FILE *, const rtx_insn *, dump_flags_t);
extern void update_br_prob_note (basic_block);
extern rtx_insn *get_last_bb_insn (basic_block);
extern void fixup_partitions (void);
extern bool purge_dead_edges (basic_block);
extern bool purge_all_dead_edges (void);
extern bool fixup_abnormal_edges (void);
extern rtx_insn *unlink_insn_chain (rtx_insn *, rtx_insn *);
extern void relink_block_chain (bool);
extern rtx_insn *duplicate_insn_chain (rtx_insn *, rtx_insn *);
extern void cfg_layout_initialize (int);
extern void cfg_layout_finalize (void);
extern void break_superblocks (void);
extern void init_rtl_bb_info (basic_block);
extern void find_bbs_reachable_by_hot_paths (hash_set <basic_block> *);
# 110 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfganal.h" 1
# 26 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfganal.h"
struct edge_list
{
int num_edges;
edge *index_to_edge;
};
class control_dependences
{
public:
control_dependences ();
~control_dependences ();
bitmap get_edges_dependent_on (int);
basic_block get_edge_src (int);
basic_block get_edge_dest (int);
private:
void set_control_dependence_map_bit (basic_block, int);
void clear_control_dependence_bitmap (basic_block);
void find_control_dependence (int);
vec<bitmap> control_dependence_map;
vec<std::pair<int, int> > m_el;
};
extern bool mark_dfs_back_edges (void);
extern void find_unreachable_blocks (void);
extern void verify_no_unreachable_blocks (void);
struct edge_list * create_edge_list (void);
void free_edge_list (struct edge_list *);
void print_edge_list (FILE *, struct edge_list *);
void verify_edge_list (FILE *, struct edge_list *);
edge find_edge (basic_block, basic_block);
int find_edge_index (struct edge_list *, basic_block, basic_block);
extern void remove_fake_edges (void);
extern void remove_fake_exit_edges (void);
extern void add_noreturn_fake_exit_edges (void);
extern void connect_infinite_loops_to_exit (void);
extern int post_order_compute (int *, bool, bool);
extern basic_block dfs_find_deadend (basic_block);
extern void inverted_post_order_compute (vec<int> *postorder, sbitmap *start_points = 0);
extern int pre_and_rev_post_order_compute_fn (struct function *,
int *, int *, bool);
extern int pre_and_rev_post_order_compute (int *, int *, bool);
extern int rev_post_order_and_mark_dfs_back_seme (struct function *, edge,
bitmap, bool, int *,
vec<std::pair<int, int> > *);
extern int dfs_enumerate_from (basic_block, int,
bool (*)(const_basic_block, const void *),
basic_block *, int, const void *);
extern void compute_dominance_frontiers (class bitmap_head *);
extern bitmap compute_idf (bitmap, class bitmap_head *);
extern void bitmap_intersection_of_succs (sbitmap, sbitmap *, basic_block);
extern void bitmap_intersection_of_preds (sbitmap, sbitmap *, basic_block);
extern void bitmap_union_of_succs (sbitmap, sbitmap *, basic_block);
extern void bitmap_union_of_preds (sbitmap, sbitmap *, basic_block);
extern basic_block * single_pred_before_succ_order (void);
extern edge single_incoming_edge_ignoring_loop_edges (basic_block, bool);
extern edge single_pred_edge_ignoring_loop_edges (basic_block, bool);
# 111 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfgbuild.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfgbuild.h"
extern bool inside_basic_block_p (const rtx_insn *);
extern bool control_flow_insn_p (const rtx_insn *);
extern void rtl_make_eh_edge (sbitmap, basic_block, rtx);
extern void find_many_sub_basic_blocks (sbitmap);
# 112 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfgcleanup.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/cfgcleanup.h"
enum replace_direction { dir_none, dir_forward, dir_backward, dir_both };
extern int flow_find_cross_jump (basic_block, basic_block, rtx_insn **,
rtx_insn **, enum replace_direction*);
extern int flow_find_head_matching_sequence (basic_block, basic_block,
rtx_insn **, rtx_insn **, int);
extern bool delete_unreachable_blocks (void);
extern void delete_dead_jumptables (void);
extern bool cleanup_cfg (int);
# 113 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.h" 1
# 24 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.h"
struct target_bb_reorder {
int x_uncond_jump_length;
};
extern struct target_bb_reorder default_target_bb_reorder;
extern struct target_bb_reorder *this_target_bb_reorder;
extern int get_uncond_jump_length (void);
extern void insert_section_boundary_note (void);
# 114 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/except.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/except.h"
struct function;
struct eh_region_d;
enum eh_region_type
{
ERT_CLEANUP,
ERT_TRY,
ERT_ALLOWED_EXCEPTIONS,
# 62 "/home/giulianob/gcc_git_gnu/gcc/gcc/except.h"
ERT_MUST_NOT_THROW
};
struct eh_landing_pad_d
{
struct eh_landing_pad_d *next_lp;
struct eh_region_d *region;
tree post_landing_pad;
rtx_code_label *landing_pad;
int index;
};
struct eh_catch_d
{
struct eh_catch_d *next_catch;
struct eh_catch_d *prev_catch;
tree type_list;
tree filter_list;
tree label;
};
struct eh_region_d
{
struct eh_region_d *outer;
struct eh_region_d *inner;
struct eh_region_d *next_peer;
int index;
enum eh_region_type type;
union eh_region_u {
struct eh_region_u_try {
struct eh_catch_d *first_catch;
struct eh_catch_d *last_catch;
} eh_try;
struct eh_region_u_allowed {
tree type_list;
tree label;
int filter;
} allowed;
struct eh_region_u_must_not_throw {
tree failure_decl;
location_t failure_loc;
} must_not_throw;
} u;
struct eh_landing_pad_d *landing_pads;
rtx exc_ptr_reg, filter_reg;
bool use_cxa_end_cleanup;
};
typedef struct eh_landing_pad_d *eh_landing_pad;
typedef struct eh_catch_d *eh_catch;
typedef struct eh_region_d *eh_region;
struct eh_status
{
eh_region region_tree;
vec<eh_region, va_gc> *region_array;
vec<eh_landing_pad, va_gc> *lp_array;
hash_map<gimple *, int> * throw_stmt_table;
vec<tree, va_gc> *ttype_data;
union eh_status_u {
vec<tree, va_gc> * arm_eabi;
vec<uchar, va_gc> * other;
} ehspec_data;
};
extern void for_each_eh_label (void (*) (rtx));
extern void init_eh_for_function (void);
extern void remove_eh_landing_pad (eh_landing_pad);
extern void remove_eh_handler (eh_region);
extern void remove_unreachable_eh_regions (sbitmap);
extern bool current_function_has_exception_handlers (void);
extern void output_function_exception_table (int);
extern rtx expand_builtin_eh_pointer (tree);
extern rtx expand_builtin_eh_filter (tree);
extern rtx expand_builtin_eh_copy_values (tree);
extern void expand_builtin_unwind_init (void);
extern rtx expand_builtin_eh_return_data_regno (tree);
extern rtx expand_builtin_extract_return_addr (tree);
extern void expand_builtin_init_dwarf_reg_sizes (tree);
extern rtx expand_builtin_frob_return_addr (tree);
extern rtx expand_builtin_dwarf_sp_column (void);
extern void expand_builtin_eh_return (tree, tree);
extern void expand_eh_return (void);
extern rtx expand_builtin_extend_pointer (tree);
typedef tree (*duplicate_eh_regions_map) (tree, void *);
extern hash_map<void *, void *> *duplicate_eh_regions
(struct function *, eh_region, int, duplicate_eh_regions_map, void *);
extern void sjlj_emit_function_exit_after (rtx_insn *);
extern void update_sjlj_context (void);
extern eh_region gen_eh_region_cleanup (eh_region);
extern eh_region gen_eh_region_try (eh_region);
extern eh_region gen_eh_region_allowed (eh_region, tree);
extern eh_region gen_eh_region_must_not_throw (eh_region);
extern eh_catch gen_eh_region_catch (eh_region, tree);
extern eh_landing_pad gen_eh_landing_pad (eh_region);
extern eh_region get_eh_region_from_number_fn (struct function *, int);
extern eh_region get_eh_region_from_number (int);
extern eh_landing_pad get_eh_landing_pad_from_number_fn (struct function*,int);
extern eh_landing_pad get_eh_landing_pad_from_number (int);
extern eh_region get_eh_region_from_lp_number_fn (struct function *, int);
extern eh_region get_eh_region_from_lp_number (int);
extern eh_region eh_region_outermost (struct function *, eh_region, eh_region);
extern void make_reg_eh_region_note (rtx_insn *insn, int ecf_flags, int lp_nr);
extern void make_reg_eh_region_note_nothrow_nononlocal (rtx_insn *);
extern void verify_eh_tree (struct function *);
extern void dump_eh_tree (FILE *, struct function *);
void debug_eh_tree (struct function *);
extern void add_type_for_runtime (tree);
extern tree lookup_type_for_runtime (tree);
extern void assign_filter_values (void);
extern eh_region get_eh_region_from_rtx (const_rtx);
extern eh_landing_pad get_eh_landing_pad_from_rtx (const_rtx);
extern void finish_eh_generation (void);
struct throw_stmt_node {
gimple *stmt;
int lp_nr;
};
extern hash_map<gimple *, int> *get_eh_throw_stmt_table (struct function *);
extern void set_eh_throw_stmt_table (function *, hash_map<gimple *, int> *);
enum eh_personality_kind {
eh_personality_none,
eh_personality_any,
eh_personality_lang
};
extern enum eh_personality_kind
function_needs_eh_personality (struct function *);
static inline eh_region
ehr_next (eh_region r, eh_region start)
{
if (r->inner)
r = r->inner;
else if (r->next_peer && r != start)
r = r->next_peer;
else
{
do
{
r = r->outer;
if (r == start)
return nullptr;
}
while (r->next_peer == nullptr);
r = r->next_peer;
}
return r;
}
# 115 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h" 1
# 45 "/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h"
template<class K, class V>
class fibonacci_heap;
template<class K, class V>
class fibonacci_node
{
typedef fibonacci_node<K,V> fibonacci_node_t;
friend class fibonacci_heap<K,V>;
public:
fibonacci_node (): m_parent (nullptr), m_child (nullptr), m_left (this),
m_right (this), m_data (nullptr), m_degree (0), m_mark (0)
{
}
fibonacci_node (K key, V *data = nullptr): m_parent (nullptr), m_child (nullptr),
m_left (this), m_right (this), m_key (key), m_data (data),
m_degree (0), m_mark (0)
{
}
int compare (fibonacci_node_t *other)
{
if (m_key < other->m_key)
return -1;
if (m_key > other->m_key)
return 1;
return 0;
}
int compare_data (K key)
{
return fibonacci_node_t (key).compare (this);
}
fibonacci_node_t *remove ();
void link (fibonacci_node_t *parent);
K get_key ()
{
return m_key;
}
V *get_data ()
{
return m_data;
}
private:
void insert_after (fibonacci_node_t *b);
void insert_before (fibonacci_node_t *b)
{
m_left->insert_after (b);
}
fibonacci_node *m_parent;
fibonacci_node *m_child;
fibonacci_node *m_left;
fibonacci_node *m_right;
K m_key;
V *m_data;
# 134 "/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h"
unsigned int m_degree : 31;
unsigned int m_mark : 1;
};
template<class K, class V>
class fibonacci_heap
{
typedef fibonacci_node<K,V> fibonacci_node_t;
friend class fibonacci_node<K,V>;
public:
fibonacci_heap (K global_min_key, pool_allocator *allocator = nullptr):
m_nodes (0), m_min (nullptr), m_root (nullptr),
m_global_min_key (global_min_key),
m_allocator (allocator), m_own_allocator (false)
{
if (!m_allocator)
{
m_allocator = new pool_allocator ("Fibonacci heap",
sizeof (fibonacci_node_t));
m_own_allocator = true;
}
}
~fibonacci_heap ()
{
if (need_finalization_p<fibonacci_node_t> () || !m_own_allocator)
while (m_min != nullptr)
{
fibonacci_node_t *n = extract_minimum_node ();
n->~fibonacci_node_t ();
if (!m_own_allocator)
m_allocator->remove (n);
}
if (m_own_allocator)
delete m_allocator;
}
fibonacci_node_t *insert (K key, V *data);
bool empty () const
{
return m_nodes == 0;
}
size_t nodes () const
{
return m_nodes;
}
K min_key () const
{
if (m_min == nullptr)
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h", 199, __FUNCTION__));
return m_min->m_key;
}
K replace_key (fibonacci_node_t *node, K key)
{
K okey = node->m_key;
replace_key_data (node, key, node->m_data);
return okey;
}
K decrease_key (fibonacci_node_t *node, K key)
{
((void)(!(key <= node->m_key) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h", 216, __FUNCTION__), 0 : 0));
return replace_key (node, key);
}
V *replace_key_data (fibonacci_node_t *node, K key, V *data);
V *extract_min (bool release = true);
V *min () const
{
if (m_min == nullptr)
return nullptr;
return m_min->m_data;
}
V *replace_data (fibonacci_node_t *node, V *data)
{
return replace_key_data (node, node->m_key, data);
}
V *delete_node (fibonacci_node_t *node, bool release = true);
fibonacci_heap *union_with (fibonacci_heap *heapb);
private:
fibonacci_node_t *insert (fibonacci_node_t *node, K key, V *data);
fibonacci_node_t *insert_node (fibonacci_node_t *node);
void insert_root (fibonacci_node_t *node);
void cut (fibonacci_node_t *node, fibonacci_node_t *parent);
void cascading_cut (fibonacci_node_t *y);
fibonacci_node_t * extract_minimum_node ();
void remove_root (fibonacci_node_t *node);
void consolidate ();
size_t m_nodes;
fibonacci_node_t *m_min;
fibonacci_node_t *m_root;
K m_global_min_key;
pool_allocator *m_allocator;
bool m_own_allocator;
};
template<class K, class V>
fibonacci_node<K,V> *
fibonacci_node<K,V>::remove ()
{
fibonacci_node<K,V> *ret;
if (this == m_left)
ret = nullptr;
else
ret = m_left;
if (m_parent != nullptr && m_parent->m_child == this)
m_parent->m_child = ret;
m_right->m_left = m_left;
m_left->m_right = m_right;
m_parent = nullptr;
m_left = this;
m_right = this;
return ret;
}
template<class K, class V>
void
fibonacci_node<K,V>::link (fibonacci_node<K,V> *parent)
{
if (parent->m_child == nullptr)
parent->m_child = this;
else
parent->m_child->insert_before (this);
m_parent = parent;
parent->m_degree++;
m_mark = 0;
}
template<class K, class V>
void
fibonacci_node<K,V>::insert_after (fibonacci_node<K,V> *b)
{
fibonacci_node<K,V> *a = this;
if (a == a->m_right)
{
a->m_right = b;
a->m_left = b;
b->m_right = a;
b->m_left = a;
}
else
{
b->m_right = a->m_right;
a->m_right->m_left = b;
a->m_right = b;
b->m_left = a;
}
}
template<class K, class V>
fibonacci_node<K,V>*
fibonacci_heap<K,V>::insert (K key, V *data)
{
fibonacci_node<K,V> *node = new (m_allocator->allocate ())
fibonacci_node_t (key, data);
return insert_node (node);
}
template<class K, class V>
fibonacci_node<K,V>*
fibonacci_heap<K,V>::insert (fibonacci_node_t *node, K key, V *data)
{
node->m_data = data;
node->m_key = key;
return insert_node (node);
}
template<class K, class V>
fibonacci_node<K,V>*
fibonacci_heap<K,V>::insert_node (fibonacci_node_t *node)
{
insert_root (node);
if (m_min == nullptr || node->m_key < m_min->m_key)
m_min = node;
m_nodes++;
return node;
}
template<class K, class V>
V*
fibonacci_heap<K,V>::replace_key_data (fibonacci_node<K,V> *node, K key,
V *data)
{
K okey;
fibonacci_node<K,V> *y;
V *odata = node->m_data;
if (node->compare_data (key) > 0)
{
delete_node (node, false);
node = new (node) fibonacci_node_t ();
insert (node, key, data);
return odata;
}
okey = node->m_key;
node->m_data = data;
node->m_key = key;
y = node->m_parent;
if (okey == key && okey != m_global_min_key)
return odata;
if (y != nullptr && node->compare (y) <= 0)
{
cut (node, y);
cascading_cut (y);
}
if (node->compare (m_min) <= 0)
m_min = node;
return odata;
}
template<class K, class V>
V*
fibonacci_heap<K,V>::extract_min (bool release)
{
fibonacci_node<K,V> *z;
V *ret = nullptr;
if (m_min != nullptr)
{
z = extract_minimum_node ();
ret = z->m_data;
if (release)
{
z->~fibonacci_node_t ();
m_allocator->remove (z);
}
}
return ret;
}
template<class K, class V>
V*
fibonacci_heap<K,V>::delete_node (fibonacci_node<K,V> *node, bool release)
{
V *ret = node->m_data;
replace_key (node, m_global_min_key);
if (node != m_min)
{
fprintf (
# 487 "/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h" 3 4
stderr
# 487 "/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h"
, "Can't force minimum on fibheap.\n");
fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h", 488, __FUNCTION__);
}
extract_min (release);
return ret;
}
template<class K, class V>
fibonacci_heap<K,V>*
fibonacci_heap<K,V>::union_with (fibonacci_heap<K,V> *heapb)
{
fibonacci_heap<K,V> *heapa = this;
fibonacci_node<K,V> *a_root, *b_root;
((void)(!(m_allocator == heapb->m_allocator) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h", 506, __FUNCTION__), 0 : 0));
if ((a_root = heapa->m_root) == nullptr)
{
delete (heapa);
return heapb;
}
if ((b_root = heapb->m_root) == nullptr)
{
delete (heapb);
return heapa;
}
a_root->m_left->m_right = b_root;
b_root->m_left->m_right = a_root;
std::swap (a_root->m_left, b_root->m_left);
heapa->m_nodes += heapb->m_nodes;
if (heapb->m_min->compare (heapa->m_min) < 0)
heapa->m_min = heapb->m_min;
heapb->m_min = nullptr;
delete (heapb);
return heapa;
}
template<class K, class V>
void
fibonacci_heap<K,V>::insert_root (fibonacci_node_t *node)
{
if (m_root == nullptr)
{
m_root = node;
node->m_left = node;
node->m_right = node;
return;
}
m_root->insert_after (node);
}
template<class K, class V>
void
fibonacci_heap<K,V>::cut (fibonacci_node<K,V> *node,
fibonacci_node<K,V> *parent)
{
node->remove ();
parent->m_degree--;
insert_root (node);
node->m_parent = nullptr;
node->m_mark = 0;
}
template<class K, class V>
void
fibonacci_heap<K,V>::cascading_cut (fibonacci_node<K,V> *y)
{
fibonacci_node<K,V> *z;
while ((z = y->m_parent) != nullptr)
{
if (y->m_mark == 0)
{
y->m_mark = 1;
return;
}
else
{
cut (y, z);
y = z;
}
}
}
template<class K, class V>
fibonacci_node<K,V>*
fibonacci_heap<K,V>::extract_minimum_node ()
{
fibonacci_node<K,V> *ret = m_min;
fibonacci_node<K,V> *x, *y, *orig;
for (x = ret->m_child, orig = nullptr; x != orig && x != nullptr; x = y)
{
if (orig == nullptr)
orig = x;
y = x->m_right;
x->m_parent = nullptr;
insert_root (x);
}
remove_root (ret);
m_nodes--;
if (m_nodes == 0)
m_min = nullptr;
else
{
m_min = ret->m_right;
consolidate ();
}
return ret;
}
template<class K, class V>
void
fibonacci_heap<K,V>::remove_root (fibonacci_node<K,V> *node)
{
if (node->m_left == node)
m_root = nullptr;
else
m_root = node->remove ();
}
template<class K, class V>
void fibonacci_heap<K,V>::consolidate ()
{
const int D = 1 + 8 * sizeof (long);
fibonacci_node<K,V> *a[D];
fibonacci_node<K,V> *w, *x, *y;
int i, d;
memset (a, 0, sizeof (a));
while ((w = m_root) != nullptr)
{
x = w;
remove_root (w);
d = x->m_degree;
((void)(!(d < D) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/fibonacci_heap.h", 662, __FUNCTION__), 0 : 0));
while (a[d] != nullptr)
{
y = a[d];
if (x->compare (y) > 0)
std::swap (x, y);
y->link (x);
a[d] = nullptr;
d++;
}
a[d] = x;
}
m_min = nullptr;
for (i = 0; i < D; i++)
if (a[i] != nullptr)
{
insert_root (a[i]);
if (m_min == nullptr || a[i]->compare (m_min) < 0)
m_min = a[i];
}
}
# 117 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/stringpool.h" 1
# 25 "/home/giulianob/gcc_git_gnu/gcc/gcc/stringpool.h"
extern tree get_identifier (const char *);
extern tree maybe_get_identifier (const char *);
extern tree get_identifier_with_length (const char *, size_t);
# 118 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h" 1
# 23 "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h"
extern const struct attribute_spec *lookup_attribute_spec (const_tree);
extern void init_attributes (void);
# 34 "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h"
extern tree decl_attributes (tree *, tree, int, tree = (tree) nullptr);
extern bool cxx11_attribute_p (const_tree);
extern tree get_attribute_name (const_tree);
extern tree get_attribute_namespace (const_tree);
extern void apply_tm_attr (tree, tree);
extern tree make_attribute (const char *, const char *, tree);
extern struct scoped_attributes* register_scoped_attributes (const struct attribute_spec *,
const char *);
extern char *sorted_attr_string (tree);
extern bool common_function_versions (tree, tree);
extern char *make_unique_name (tree, const char *, bool);
extern tree make_dispatcher_decl (const tree);
extern bool is_function_default_version (const tree);
extern tree build_type_attribute_variant (tree, tree);
extern tree build_decl_attribute_variant (tree, tree);
extern tree build_type_attribute_qual_variant (tree, tree, int);
extern bool attribute_value_equal (const_tree, const_tree);
extern int comp_type_attributes (const_tree, const_tree);
extern tree merge_decl_attributes (tree, tree);
extern tree merge_type_attributes (tree, tree);
extern tree remove_attribute (const char *, tree);
extern tree merge_attributes (tree, tree);
extern void duplicate_one_attribute (tree *, tree, const char *);
extern void copy_attributes_to_builtin (tree);
extern tree merge_dllimport_decl_attributes (tree, tree);
extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
extern int attribute_list_equal (const_tree, const_tree);
extern int attribute_list_contained (const_tree, const_tree);
extern tree private_lookup_attribute (const char *attr_name, size_t attr_len,
tree list);
extern unsigned decls_mismatched_attributes (tree, tree, tree,
const char* const[],
pretty_printer*);
extern void maybe_diag_alias_attributes (tree, tree);
static inline tree
canonicalize_attr_name (tree attr_name)
{
const size_t l = ((tree_check ((attr_name), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 121, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len);
const char *s = ((const char *) (tree_check ((attr_name), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 122, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str);
if (l > 4 && s[0] == '_' && s[1] == '_' && s[l - 1] == '_' && s[l - 2] == '_')
return get_identifier_with_length (s + 2, l - 4);
return attr_name;
}
static inline bool
cmp_attribs (const char *attr1, size_t attr1_len,
const char *attr2, size_t attr2_len)
{
return attr1_len == attr2_len && strncmp (attr1, attr2, attr1_len) == 0;
}
static inline bool
cmp_attribs (const char *attr1, const char *attr2)
{
return cmp_attribs (attr1, strlen (attr1), attr2, strlen (attr2));
}
static inline bool
is_attribute_p (const char *attr_name, const_tree ident)
{
return cmp_attribs (attr_name, strlen (attr_name),
((const char *) (tree_check ((ident), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 155, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str), ((tree_check ((ident), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 155, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len));
}
# 166 "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h"
static inline tree
lookup_attribute (const char *attr_name, tree list)
{
((void)(!(attr_name[0] != '_') ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 169, __FUNCTION__), 0 : 0));
if (list == (tree) nullptr)
return (tree) nullptr;
else
{
size_t attr_len = strlen (attr_name);
return private_lookup_attribute (attr_name, attr_len, list);
}
}
static inline tree
lookup_attribute_by_prefix (const char *attr_name, tree list)
{
((void)(!(attr_name[0] != '_') ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 191, __FUNCTION__), 0 : 0));
if (list == (tree) nullptr)
return (tree) nullptr;
else
{
size_t attr_len = strlen (attr_name);
while (list)
{
size_t ident_len = ((tree_check ((get_attribute_name (list)), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 200, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len);
if (attr_len > ident_len)
{
list = ((contains_struct_check ((list), (TS_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 204, __FUNCTION__))->common.chain);
continue;
}
const char *p = ((const char *) (tree_check ((get_attribute_name (list)), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 208, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str);
((void)(!(attr_len == 0 || p[0] != '_') ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 209, __FUNCTION__), 0 : 0));
if (strncmp (attr_name, p, attr_len) == 0)
break;
list = ((contains_struct_check ((list), (TS_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/attribs.h", 214, __FUNCTION__))->common.chain);
}
return list;
}
}
struct attr_access
{
tree ptr;
tree size;
unsigned ptrarg;
unsigned sizarg;
enum access_mode { none, read_only, write_only, read_write };
access_mode mode;
};
struct rdwr_access_hash: int_hash<int, -1> { };
struct attr_access;
typedef hash_map<rdwr_access_hash, attr_access> rdwr_map;
extern void init_attr_rdwr_indices (rdwr_map *, tree);
# 119 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.h" 1
# 28 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.h"
enum opt_levels
{
OPT_LEVELS_NONE,
OPT_LEVELS_ALL,
OPT_LEVELS_0_ONLY,
OPT_LEVELS_1_PLUS,
OPT_LEVELS_1_PLUS_SPEED_ONLY,
OPT_LEVELS_1_PLUS_NOT_DEBUG,
OPT_LEVELS_2_PLUS,
OPT_LEVELS_2_PLUS_SPEED_ONLY,
OPT_LEVELS_3_PLUS,
OPT_LEVELS_3_PLUS_AND_SIZE,
OPT_LEVELS_SIZE,
OPT_LEVELS_FAST
};
struct default_options
{
enum opt_levels levels;
size_t opt_index;
const char *arg;
int value;
};
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.def" 1
# 20 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.def"
# 1 "/home/giulianob/gcc_git_gnu/gcc/gcc/target-hooks-macros.h" 1
# 21 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.def" 2
struct gcc_targetm_common {
bool (* handle_option) (struct gcc_options *opts, struct gcc_options *opts_set, const struct cl_decoded_option *decoded, location_t loc);
void (* option_init_struct) (struct gcc_options *opts);
const struct default_options * option_optimization_table;
int default_target_flags;
enum unwind_info_type (* except_unwind_info) (struct gcc_options *opts);
bool (* supports_split_stack) (bool report, struct gcc_options *opts);
# 76 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.def"
vec<const char *> (* get_valid_option_values) (int option_code, const char *prefix);
# 90 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.def"
bool unwind_tables_default;
bool have_named_sections;
bool always_strip_dotdot;
} ;
# 68 "/home/giulianob/gcc_git_gnu/gcc/gcc/common/common-target.h" 2
extern struct gcc_targetm_common targetm_common;
# 120 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 2
struct target_bb_reorder default_target_bb_reorder;
struct target_bb_reorder *this_target_bb_reorder = &default_target_bb_reorder;
static const int branch_threshold[5] = {400, 200, 100, 0, 0};
static const int exec_threshold[5] = {500, 200, 50, 0, 0};
typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
typedef fibonacci_node <long, basic_block_def> bb_heap_node_t;
struct bbro_basic_block_data
{
int start_of_trace;
int end_of_trace;
int in_trace;
int visited;
int priority;
bb_heap_t *heap;
bb_heap_node_t *node;
};
static int array_size;
static bbro_basic_block_data *bbd;
# 187 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
struct trace
{
basic_block first, last;
int round;
int length;
};
static profile_count max_entry_count;
static void find_traces_1_round (int, profile_count, struct trace *, int *,
int, bb_heap_t **, int);
static basic_block copy_bb (basic_block, edge, basic_block, int);
static long bb_to_key (basic_block);
static bool better_edge_p (const_basic_block, const_edge, profile_probability,
profile_count, profile_probability, profile_count,
const_edge);
static bool copy_bb_p (const_basic_block, int);
static int
bb_visited_trace (const_basic_block bb)
{
((void)(!(bb->index < array_size) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 217, __FUNCTION__), 0 : 0));
return bbd[bb->index].visited;
}
static void
mark_bb_visited (basic_block bb, int trace)
{
bbd[bb->index].visited = trace;
if (bbd[bb->index].heap)
{
bbd[bb->index].heap->delete_node (bbd[bb->index].node);
bbd[bb->index].heap = nullptr;
bbd[bb->index].node = nullptr;
}
}
# 243 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
static bool
push_to_next_round_p (const_basic_block bb, int round, int number_of_rounds,
profile_count count_th)
{
bool there_exists_another_round;
bool block_not_hot_enough;
there_exists_another_round = round < number_of_rounds - 1;
block_not_hot_enough = (bb->count < count_th
|| probably_never_executed_bb_p ((cfun + 0), bb));
if (there_exists_another_round
&& block_not_hot_enough)
return true;
else
return false;
}
static void
find_traces (int *n_traces, struct trace *traces)
{
int i;
int number_of_rounds;
edge e;
edge_iterator ei;
bb_heap_t *heap = new bb_heap_t (
# 273 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 3 4
(-0x7fffffffffffffffL - 1L)
# 273 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
);
number_of_rounds = 5 - 1;
max_entry_count = profile_count::zero ();
for ((ei) = ei_start_1 (&(((((cfun + 0))->cfg->x_entry_block_ptr)->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
bbd[e->dest->index].heap = heap;
bbd[e->dest->index].node = heap->insert (bb_to_key (e->dest), e->dest);
if (e->dest->count > max_entry_count)
max_entry_count = e->dest->count;
}
for (i = 0; i < number_of_rounds; i++)
{
profile_count count_threshold;
if (dump_file)
fprintf (dump_file, "STC - round %d\n", i + 1);
count_threshold = max_entry_count.apply_scale (exec_threshold[i], 1000);
find_traces_1_round (10000 * branch_threshold[i] / 1000,
count_threshold, traces, n_traces, i, &heap,
number_of_rounds);
}
delete heap;
if (dump_file)
{
for (i = 0; i < *n_traces; i++)
{
basic_block bb;
fprintf (dump_file, "Trace %d (round %d): ", i + 1,
traces[i].round + 1);
for (bb = traces[i].first;
bb != traces[i].last;
bb = (basic_block) bb->aux)
{
fprintf (dump_file, "%d [", bb->index);
bb->count.dump (dump_file);
fprintf (dump_file, "] ");
}
fprintf (dump_file, "%d [", bb->index);
bb->count.dump (dump_file);
fprintf (dump_file, "]\n");
}
fflush (dump_file);
}
}
static basic_block
rotate_loop (edge back_edge, struct trace *trace, int trace_n)
{
basic_block bb;
basic_block best_bb = nullptr;
edge best_edge = nullptr;
profile_count best_count = profile_count::uninitialized ();
bool is_preferred = false;
bb = back_edge->dest;
do
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->dest != (((cfun + 0))->cfg->x_exit_block_ptr)
&& bb_visited_trace (e->dest) != trace_n
&& (e->flags & EDGE_CAN_FALLTHRU)
&& !(e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)))
{
if (is_preferred)
{
if (!bb_visited_trace (e->dest)
|| bbd[e->dest->index].start_of_trace >= 0)
{
if (e->count () > best_count)
{
best_count = e->count ();
best_edge = e;
best_bb = bb;
}
}
}
else
{
if (!bb_visited_trace (e->dest)
|| bbd[e->dest->index].start_of_trace >= 0)
{
is_preferred = true;
best_count = e->count ();
best_edge = e;
best_bb = bb;
}
else
{
if (!best_edge || e->count () > best_count)
{
best_count = e->count ();
best_edge = e;
best_bb = bb;
}
}
}
}
bb = (basic_block) bb->aux;
}
while (bb != back_edge->dest);
if (best_bb)
{
if (back_edge->dest == trace->first)
{
trace->first = (basic_block) best_bb->aux;
}
else
{
basic_block prev_bb;
for (prev_bb = trace->first;
prev_bb->aux != back_edge->dest;
prev_bb = (basic_block) prev_bb->aux)
;
prev_bb->aux = best_bb->aux;
if (single_succ_p (prev_bb))
{
basic_block header = single_succ (prev_bb);
if (any_condjump_p ((header)->il.x.rtl->end_) && copy_bb_p (header, 0)
&& !(__extension__ ({ __typeof (((header)->il.x.rtl->end_)) const _rtx = (((header)->il.x.rtl->end_)); if (((enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 426, __FUNCTION__); _rtx; })->jump))
copy_bb (header, single_succ_edge (prev_bb), prev_bb, trace_n);
}
}
}
else
{
best_bb = back_edge->src;
}
best_bb->aux = nullptr;
return best_bb;
}
# 448 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
static void
find_traces_1_round (int branch_th, profile_count count_th,
struct trace *traces, int *n_traces, int round,
bb_heap_t **heap, int number_of_rounds)
{
bb_heap_t *new_heap = new bb_heap_t (
# 455 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c" 3 4
(-0x7fffffffffffffffL - 1L)
# 455 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
);
bool for_size = optimize_function_for_size_p ((cfun + 0));
while (!(*heap)->empty ())
{
basic_block bb;
struct trace *trace;
edge best_edge, e;
long key;
edge_iterator ei;
bb = (*heap)->extract_min ();
bbd[bb->index].heap = nullptr;
bbd[bb->index].node = nullptr;
if (dump_file)
fprintf (dump_file, "Getting bb %d\n", bb->index);
if (!for_size
&& push_to_next_round_p (bb, round, number_of_rounds,
count_th))
{
int key = bb_to_key (bb);
bbd[bb->index].heap = new_heap;
bbd[bb->index].node = new_heap->insert (key, bb);
if (dump_file)
fprintf (dump_file,
" Possible start point of next round: %d (key: %d)\n",
bb->index, key);
continue;
}
trace = traces + *n_traces;
trace->first = bb;
trace->round = round;
trace->length = 0;
bbd[bb->index].in_trace = *n_traces;
(*n_traces)++;
do
{
bool ends_in_call;
profile_probability best_prob = profile_probability::uninitialized ();
profile_count best_count = profile_count::uninitialized ();
best_edge = nullptr;
mark_bb_visited (bb, *n_traces);
trace->length++;
if (dump_file)
fprintf (dump_file, "Basic block %d was visited in trace %d\n",
bb->index, *n_traces);
ends_in_call = block_ends_with_call_p (bb);
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
((void)(!(!(e->flags & EDGE_FAKE)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 521, __FUNCTION__), 0 : 0));
if (e->dest == (((cfun + 0))->cfg->x_exit_block_ptr))
continue;
if (bb_visited_trace (e->dest)
&& bb_visited_trace (e->dest) != *n_traces)
continue;
if (((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
continue;
profile_probability prob = e->probability;
profile_count count = e->dest->count;
if (ends_in_call)
{
if (e->flags & EDGE_CAN_FALLTHRU)
{
best_edge = e;
best_prob = prob;
best_count = count;
}
continue;
}
if (!(e->flags & EDGE_CAN_FALLTHRU) || (e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
|| !prob.initialized_p ()
|| ((prob.to_reg_br_prob_base () < branch_th
|| e->count () < count_th) && (!for_size)))
continue;
if (better_edge_p (bb, e, prob, count, best_prob, best_count,
best_edge))
{
best_edge = e;
best_prob = prob;
best_count = count;
}
}
if (best_edge
&& vec_safe_length (best_edge->dest->preds) >= 2
&& copy_bb_p (best_edge->dest, 0))
{
bool only_crossing_preds = true;
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((best_edge->dest->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e != best_edge && !(e->flags & EDGE_CROSSING))
{
only_crossing_preds = false;
break;
}
if (!only_crossing_preds)
best_edge = nullptr;
}
# 611 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
if (best_edge && for_size
&& (vec_safe_length (best_edge->dest->succs) > 1
|| vec_safe_length (best_edge->dest->preds) > 1))
best_edge = nullptr;
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
if (e == best_edge
|| e->dest == (((cfun + 0))->cfg->x_exit_block_ptr)
|| bb_visited_trace (e->dest))
continue;
key = bb_to_key (e->dest);
if (bbd[e->dest->index].heap)
{
if (key != bbd[e->dest->index].node->get_key ())
{
if (dump_file)
{
fprintf (dump_file,
"Changing key for bb %d from %ld to %ld.\n",
e->dest->index,
(long) bbd[e->dest->index].node->get_key (),
key);
}
bbd[e->dest->index].heap->replace_key
(bbd[e->dest->index].node, key);
}
}
else
{
bb_heap_t *which_heap = *heap;
profile_probability prob = e->probability;
if (!(e->flags & EDGE_CAN_FALLTHRU)
|| (e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
|| !prob.initialized_p ()
|| prob.to_reg_br_prob_base () < branch_th
|| e->count () < count_th)
{
if (!for_size && push_to_next_round_p (e->dest, round,
number_of_rounds,
count_th))
which_heap = new_heap;
}
bbd[e->dest->index].heap = which_heap;
bbd[e->dest->index].node = which_heap->insert (key, e->dest);
if (dump_file)
{
fprintf (dump_file,
" Possible start of %s round: %d (key: %ld)\n",
(which_heap == new_heap) ? "next" : "this",
e->dest->index, (long) key);
}
}
}
if (best_edge)
{
if (bb_visited_trace (best_edge->dest) == *n_traces)
{
if (best_edge->dest != bb)
{
if (best_edge->count ()
> best_edge->dest->count.apply_scale (4, 5))
{
if (best_edge->dest
!= (((cfun + 0))->cfg->x_entry_block_ptr)->next_bb)
{
if (dump_file)
{
fprintf (dump_file,
"Rotating loop %d - %d\n",
best_edge->dest->index, bb->index);
}
bb->aux = best_edge->dest;
bbd[best_edge->dest->index].in_trace =
(*n_traces) - 1;
bb = rotate_loop (best_edge, trace, *n_traces);
}
}
else
{
if (single_succ_p (bb)
&& copy_bb_p (best_edge->dest,
optimize_edge_for_speed_p
(best_edge)))
{
bb = copy_bb (best_edge->dest, best_edge, bb,
*n_traces);
trace->length++;
}
}
}
break;
}
else
{
# 752 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e != best_edge
&& (e->flags & EDGE_CAN_FALLTHRU)
&& !(e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
&& !bb_visited_trace (e->dest)
&& single_pred_p (e->dest)
&& !(e->flags & EDGE_CROSSING)
&& single_succ_p (e->dest)
&& (single_succ_edge (e->dest)->flags
& EDGE_CAN_FALLTHRU)
&& !(single_succ_edge (e->dest)->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
&& single_succ (e->dest) == best_edge->dest
&& (e->dest->count.apply_scale (2, 1)
>= best_edge->count () || for_size))
{
best_edge = e;
if (dump_file)
fprintf (dump_file, "Selecting BB %d\n",
best_edge->dest->index);
break;
}
bb->aux = best_edge->dest;
bbd[best_edge->dest->index].in_trace = (*n_traces) - 1;
bb = best_edge->dest;
}
}
}
while (best_edge);
trace->last = bb;
bbd[trace->first->index].start_of_trace = *n_traces - 1;
if (bbd[trace->last->index].end_of_trace != *n_traces - 1)
{
bbd[trace->last->index].end_of_trace = *n_traces - 1;
for ((ei) = ei_start_1 (&((trace->last->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->count ().to_frequency ((cfun + 0)) > bbd[e->dest->index].priority)
bbd[e->dest->index].priority = e->count ().to_frequency ((cfun + 0));
}
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
if (e->dest == (((cfun + 0))->cfg->x_exit_block_ptr)
|| bb_visited_trace (e->dest))
continue;
if (bbd[e->dest->index].heap)
{
key = bb_to_key (e->dest);
if (key != bbd[e->dest->index].node->get_key ())
{
if (dump_file)
{
fprintf (dump_file,
"Changing key for bb %d from %ld to %ld.\n",
e->dest->index,
(long) bbd[e->dest->index].node->get_key (), key);
}
bbd[e->dest->index].heap->replace_key
(bbd[e->dest->index].node, key);
}
}
}
}
delete (*heap);
*heap = new_heap;
}
static basic_block
copy_bb (basic_block old_bb, edge e, basic_block bb, int trace)
{
basic_block new_bb;
new_bb = duplicate_block (old_bb, e, bb);
do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((old_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while (0);
((void)(!(e->dest == new_bb) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 839, __FUNCTION__), 0 : 0));
if (dump_file)
fprintf (dump_file,
"Duplicated bb %d (created bb %d)\n",
old_bb->index, new_bb->index);
if (new_bb->index >= array_size
|| (((cfun + 0))->cfg->x_last_basic_block) > array_size)
{
int i;
int new_size;
new_size = (((((cfun + 0))->cfg->x_last_basic_block)) > (new_bb->index + 1) ? ((((cfun + 0))->cfg->x_last_basic_block)) : (new_bb->index + 1));
new_size = ((((new_size) / 4) + 1) * 5);
bbd = ((bbro_basic_block_data *) xrealloc ((void *) (bbd), sizeof (bbro_basic_block_data) * (new_size)));
for (i = array_size; i < new_size; i++)
{
bbd[i].start_of_trace = -1;
bbd[i].end_of_trace = -1;
bbd[i].in_trace = -1;
bbd[i].visited = 0;
bbd[i].priority = -1;
bbd[i].heap = nullptr;
bbd[i].node = nullptr;
}
array_size = new_size;
if (dump_file)
{
fprintf (dump_file,
"Growing the dynamic array to %d elements.\n",
array_size);
}
}
((void)(!(!bb_visited_trace (e->dest)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 875, __FUNCTION__), 0 : 0));
mark_bb_visited (new_bb, trace);
new_bb->aux = bb->aux;
bb->aux = new_bb;
bbd[new_bb->index].in_trace = trace;
return new_bb;
}
static long
bb_to_key (basic_block bb)
{
edge e;
edge_iterator ei;
if (optimize_function_for_size_p ((cfun + 0)))
return bb->index;
if (((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == BB_COLD_PARTITION
|| probably_never_executed_bb_p ((cfun + 0), bb))
return 10000;
int priority = bbd[bb->index].priority;
if (priority == -1)
{
priority = 0;
for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
if ((e->src != (((cfun + 0))->cfg->x_entry_block_ptr)
&& bbd[e->src->index].end_of_trace >= 0)
|| (e->flags & EDGE_DFS_BACK))
{
int edge_freq = e->count ().to_frequency ((cfun + 0));
if (edge_freq > priority)
priority = edge_freq;
}
}
bbd[bb->index].priority = priority;
}
if (priority)
return -(100 * 10000 + 100 * priority + bb->count.to_frequency ((cfun + 0)));
return -bb->count.to_frequency ((cfun + 0));
}
# 938 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
static bool
better_edge_p (const_basic_block bb, const_edge e, profile_probability prob,
profile_count count, profile_probability best_prob,
profile_count best_count, const_edge cur_best_edge)
{
bool is_better_edge;
profile_probability diff_prob = best_prob.apply_scale (1, 10);
if (optimize_function_for_size_p ((cfun + 0)))
return !cur_best_edge
|| cur_best_edge->dest->index > e->dest->index;
if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
return false;
if (prob > best_prob + diff_prob
|| (!best_prob.initialized_p ()
&& prob > profile_probability::guessed_never ()))
is_better_edge = true;
else if (prob < best_prob - diff_prob)
is_better_edge = false;
else
{
profile_count diff_count = best_count.apply_scale (1, 10);
if (count < best_count - diff_count
|| (!best_count.initialized_p ()
&& count.nonzero_p ()))
is_better_edge = true;
else if (count > best_count + diff_count)
is_better_edge = false;
else if (e->dest->prev_bb == bb)
is_better_edge = true;
else
is_better_edge = false;
}
return is_better_edge;
}
# 1001 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
static bool
connect_better_edge_p (const_edge e, bool src_index_p, int best_len,
const_edge cur_best_edge, struct trace *traces)
{
int e_index;
int b_index;
bool is_better_edge;
if (!cur_best_edge)
return true;
if (optimize_function_for_size_p ((cfun + 0)))
{
e_index = src_index_p ? e->src->index : e->dest->index;
b_index = src_index_p ? cur_best_edge->src->index
: cur_best_edge->dest->index;
return b_index > e_index;
}
if (src_index_p)
{
e_index = e->src->index;
if (e->count () > cur_best_edge->count ())
is_better_edge = true;
else if (e->count () < cur_best_edge->count ())
is_better_edge = false;
else if (e->probability > cur_best_edge->probability)
is_better_edge = true;
else if (e->probability < cur_best_edge->probability)
is_better_edge = false;
else if (traces[bbd[e_index].end_of_trace].length > best_len)
is_better_edge = true;
else
is_better_edge = false;
}
else
{
e_index = e->dest->index;
if (e->probability > cur_best_edge->probability)
is_better_edge = true;
else if (e->probability < cur_best_edge->probability)
is_better_edge = false;
else if (traces[bbd[e_index].start_of_trace].length > best_len)
is_better_edge = true;
else
is_better_edge = false;
}
return is_better_edge;
}
static void
connect_traces (int n_traces, struct trace *traces)
{
int i;
bool *connected;
bool two_passes;
int last_trace;
int current_pass;
int current_partition;
profile_count count_threshold;
bool for_size = optimize_function_for_size_p ((cfun + 0));
count_threshold = max_entry_count.apply_scale (100, 1000);
connected = ((bool *) xcalloc ((n_traces), sizeof (bool)));
last_trace = -1;
current_pass = 1;
current_partition = ((traces[0].first)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
two_passes = false;
if ((&x_rtl)->has_bb_partition)
for (i = 0; i < n_traces && !two_passes; i++)
if (((traces[0].first)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
!= ((traces[i].first)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
two_passes = true;
for (i = 0; i < n_traces || (two_passes && current_pass == 1) ; i++)
{
int t = i;
int t2;
edge e, best;
int best_len;
if (i >= n_traces)
{
((void)(!(two_passes && current_pass == 1) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1106, __FUNCTION__), 0 : 0));
i = 0;
t = i;
current_pass = 2;
if (current_partition == BB_HOT_PARTITION)
current_partition = BB_COLD_PARTITION;
else
current_partition = BB_HOT_PARTITION;
}
if (connected[t])
continue;
if (two_passes
&& ((traces[t].first)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != current_partition)
continue;
connected[t] = true;
for (t2 = t; t2 > 0;)
{
edge_iterator ei;
best = nullptr;
best_len = 0;
for ((ei) = ei_start_1 (&((traces[t2].first->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
int si = e->src->index;
if (e->src != (((cfun + 0))->cfg->x_entry_block_ptr)
&& (e->flags & EDGE_CAN_FALLTHRU)
&& !(e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
&& bbd[si].end_of_trace >= 0
&& !connected[bbd[si].end_of_trace]
&& (((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == current_partition)
&& connect_better_edge_p (e, true, best_len, best, traces))
{
best = e;
best_len = traces[bbd[si].end_of_trace].length;
}
}
if (best)
{
best->src->aux = best->dest;
t2 = bbd[best->src->index].end_of_trace;
connected[t2] = true;
if (dump_file)
{
fprintf (dump_file, "Connection: %d %d\n",
best->src->index, best->dest->index);
}
}
else
break;
}
if (last_trace >= 0)
traces[last_trace].last->aux = traces[t2].first;
last_trace = t;
while (1)
{
edge_iterator ei;
best = nullptr;
best_len = 0;
for ((ei) = ei_start_1 (&((traces[t].last->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
int di = e->dest->index;
if (e->dest != (((cfun + 0))->cfg->x_exit_block_ptr)
&& (e->flags & EDGE_CAN_FALLTHRU)
&& !(e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
&& bbd[di].start_of_trace >= 0
&& !connected[bbd[di].start_of_trace]
&& (((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == current_partition)
&& connect_better_edge_p (e, false, best_len, best, traces))
{
best = e;
best_len = traces[bbd[di].start_of_trace].length;
}
}
if (for_size)
{
if (!best)
break;
if (best->dest->index > (traces[t].last->index + 1))
{
int count = vec_safe_length (best->dest->preds);
for ((ei) = ei_start_1 (&((best->dest->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->flags & EDGE_DFS_BACK)
count--;
if (count != 1)
break;
}
if (last_trace != bbd[best->dest->index].start_of_trace - 1)
break;
if (dump_file)
fprintf (dump_file, "Connection: %d %d\n",
best->src->index, best->dest->index);
t = bbd[best->dest->index].start_of_trace;
traces[last_trace].last->aux = traces[t].first;
connected[t] = true;
last_trace = t;
}
else if (best)
{
if (dump_file)
{
fprintf (dump_file, "Connection: %d %d\n",
best->src->index, best->dest->index);
}
t = bbd[best->dest->index].start_of_trace;
traces[last_trace].last->aux = traces[t].first;
connected[t] = true;
last_trace = t;
}
else
{
edge e2;
basic_block next_bb = nullptr;
bool try_copy = false;
for ((ei) = ei_start_1 (&((traces[t].last->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->dest != (((cfun + 0))->cfg->x_exit_block_ptr)
&& (e->flags & EDGE_CAN_FALLTHRU)
&& !(e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
&& (!best || e->probability > best->probability))
{
edge_iterator ei;
edge best2 = nullptr;
int best2_len = 0;
if (bbd[e->dest->index].start_of_trace >= 0
&& traces[bbd[e->dest->index].start_of_trace].length
== 1)
{
best = e;
try_copy = true;
continue;
}
for ((ei) = ei_start_1 (&((e->dest->succs))); ei_cond ((ei), &(e2)); ei_next (&(ei)))
{
int di = e2->dest->index;
if (e2->dest == (((cfun + 0))->cfg->x_exit_block_ptr)
|| ((e2->flags & EDGE_CAN_FALLTHRU)
&& !(e2->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE))
&& bbd[di].start_of_trace >= 0
&& !connected[bbd[di].start_of_trace]
&& ((e2->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == current_partition
&& e2->count () >= count_threshold
&& (!best2
|| e2->probability > best2->probability
|| (e2->probability == best2->probability
&& traces[bbd[di].start_of_trace].length
> best2_len))))
{
best = e;
best2 = e2;
if (e2->dest != (((cfun + 0))->cfg->x_exit_block_ptr))
best2_len = traces[bbd[di].start_of_trace].length;
else
best2_len = 0x7fffffff;
next_bb = e2->dest;
try_copy = true;
}
}
}
if (try_copy
&& ((best->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == ((best->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
&& copy_bb_p (best->dest,
optimize_edge_for_speed_p (best)
&& (!best->count ().initialized_p ()
|| best->count () >= count_threshold)))
{
basic_block new_bb;
if (dump_file)
{
fprintf (dump_file, "Connection: %d %d ",
traces[t].last->index, best->dest->index);
if (!next_bb)
fputc ('\n', dump_file);
else if (next_bb == (((cfun + 0))->cfg->x_exit_block_ptr))
fprintf (dump_file, "exit\n");
else
fprintf (dump_file, "%d\n", next_bb->index);
}
new_bb = copy_bb (best->dest, best, traces[t].last, t);
traces[t].last = new_bb;
if (next_bb && next_bb != (((cfun + 0))->cfg->x_exit_block_ptr))
{
t = bbd[next_bb->index].start_of_trace;
traces[last_trace].last->aux = traces[t].first;
connected[t] = true;
last_trace = t;
}
else
break;
}
else
break;
}
}
}
if (dump_file)
{
basic_block bb;
fprintf (dump_file, "Final order:\n");
for (bb = traces[0].first; bb; bb = (basic_block) bb->aux)
fprintf (dump_file, "%d ", bb->index);
fprintf (dump_file, "\n");
fflush (dump_file);
}
(((void)(!(connected) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1351, __FUNCTION__), 0 : 0)), free (connected), connected = 0);
}
static bool
copy_bb_p (const_basic_block bb, int code_may_grow)
{
unsigned int size = 0;
unsigned int max_size = (this_target_bb_reorder->x_uncond_jump_length);
rtx_insn *insn;
if (vec_safe_length (bb->preds) < 2)
return false;
if (!can_duplicate_block_p (bb))
return false;
if (vec_safe_length (bb->succs) > 8)
return false;
if (code_may_grow && optimize_bb_for_speed_p (bb))
max_size *= global_options.x_param_max_grow_copy_bb_insns;
for ((insn) = (bb)->il.x.head_; (insn) && (insn) != NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (insn))
{
if ((((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) == DEBUG_INSN)))
{
size += get_attr_min_length (insn);
if (size > max_size)
break;
}
}
if (size <= max_size)
return true;
if (dump_file)
{
fprintf (dump_file,
"Block %d can't be copied because its size = %u.\n",
bb->index, size);
}
return false;
}
int
get_uncond_jump_length (void)
{
unsigned int length;
start_sequence ();
rtx_code_label *label = emit_label (gen_label_rtx ());
rtx_insn *jump = emit_jump_insn (targetm.gen_jump (label));
length = get_attr_min_length (jump);
end_sequence ();
((void)(!(length < 0x7fffffff) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1412, __FUNCTION__), 0 : 0));
return length;
}
static basic_block
create_eh_forwarder_block (rtx_code_label *new_label, basic_block old_bb)
{
old_bb = split_block_after_labels (old_bb)->dest;
rtx_insn *label = emit_label (new_label);
rtx_code_label *old_label = block_label (old_bb);
rtx_insn *jump = emit_jump_insn (targetm.gen_jump (old_label));
(((jump)->u.fld[7]).rt_rtx) = old_label;
basic_block last_bb = (((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb;
basic_block new_bb = create_basic_block (label, jump, last_bb);
new_bb->aux = last_bb->aux;
new_bb->count = old_bb->count;
last_bb->aux = new_bb;
emit_barrier_after_bb (new_bb);
make_single_succ_edge (new_bb, old_bb, 0);
unsigned new_partition = ((old_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
new_partition ^= BB_HOT_PARTITION | BB_COLD_PARTITION;
do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (new_partition)); } while (0);
return new_bb;
}
static void
sjlj_fix_up_crossing_landing_pad (basic_block old_bb)
{
const unsigned lp_len = (cfun + 0)->eh->lp_array->length ();
edge_iterator ei;
edge e;
rtx_code_label *new_label = gen_label_rtx ();
(__extension__ ({ __typeof ((new_label)) const _rtx = ((new_label)); if (((enum rtx_code) (_rtx)->code) != CODE_LABEL && ((enum rtx_code) (_rtx)->code) != NOTE) rtl_check_failed_flag ("LABEL_PRESERVE_P",_rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1464, __FUNCTION__); _rtx; })->in_struct) = 1;
basic_block new_bb = create_eh_forwarder_block (new_label, old_bb);
unsigned *index_map = (unsigned *) __builtin_alloca(lp_len * sizeof (unsigned));
memset (index_map, 0, lp_len * sizeof (unsigned));
for (ei = ei_start_1 (&(old_bb->preds)); (e = ei_safe_edge (ei)) != nullptr; )
if (e->src != new_bb && ((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == ((new_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
{
rtx_insn *insn = (e->src)->il.x.rtl->end_;
rtx note = find_reg_note (insn, REG_EH_REGION, (rtx) 0);
((void)(!(note != nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1480, __FUNCTION__), 0 : 0));
const unsigned old_index = (((((note)->u.fld[0]).rt_rtx))->u.hwint[0]);
if (index_map[old_index] == 0)
{
eh_landing_pad old_lp = (*(cfun + 0)->eh->lp_array)[old_index];
eh_landing_pad new_lp = gen_eh_landing_pad (old_lp->region);
new_lp->post_landing_pad = old_lp->post_landing_pad;
new_lp->landing_pad = new_label;
index_map[old_index] = new_lp->index;
}
(((note)->u.fld[0]).rt_rtx) = gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (index_map[old_index]));
redirect_edge_succ (e, new_bb);
}
else
ei_next (&ei);
}
static void
dw2_fix_up_crossing_landing_pad (eh_landing_pad old_lp, basic_block old_bb)
{
eh_landing_pad new_lp;
edge_iterator ei;
edge e;
new_lp = gen_eh_landing_pad (old_lp->region);
new_lp->post_landing_pad = old_lp->post_landing_pad;
new_lp->landing_pad = gen_label_rtx ();
(__extension__ ({ __typeof ((new_lp->landing_pad)) const _rtx = ((new_lp->landing_pad)); if (((enum rtx_code) (_rtx)->code) != CODE_LABEL && ((enum rtx_code) (_rtx)->code) != NOTE) rtl_check_failed_flag ("LABEL_PRESERVE_P",_rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1516, __FUNCTION__); _rtx; })->in_struct) = 1;
basic_block new_bb = create_eh_forwarder_block (new_lp->landing_pad, old_bb);
for (ei = ei_start_1 (&(old_bb->preds)); (e = ei_safe_edge (ei)) != nullptr; )
if (e->src != new_bb && ((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == ((new_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
{
rtx_insn *insn = (e->src)->il.x.rtl->end_;
rtx note = find_reg_note (insn, REG_EH_REGION, (rtx) 0);
((void)(!(note != nullptr) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1528, __FUNCTION__), 0 : 0));
((void)(!((((((note)->u.fld[0]).rt_rtx))->u.hwint[0]) == old_lp->index) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1529, __FUNCTION__), 0 : 0));
(((note)->u.fld[0]).rt_rtx) = gen_rtx_CONST_INT (((void) 0, E_VOIDmode), (new_lp->index));
redirect_edge_succ (e, new_bb);
}
else
ei_next (&ei);
}
# 1547 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
static unsigned int
sanitize_hot_paths (bool walk_up, unsigned int cold_bb_count,
vec<basic_block> *bbs_in_hot_partition)
{
((void)(!(cold_bb_count) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1552, __FUNCTION__), 0 : 0));
vec<basic_block> hot_bbs_to_check = bbs_in_hot_partition->copy ();
while (! hot_bbs_to_check.is_empty ()
&& cold_bb_count)
{
basic_block bb = hot_bbs_to_check.pop ();
vec<edge, va_gc> *edges = walk_up ? bb->preds : bb->succs;
edge e;
edge_iterator ei;
profile_probability highest_probability
= profile_probability::uninitialized ();
profile_count highest_count = profile_count::uninitialized ();
bool found = false;
for ((ei) = ei_start_1 (&((edges))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
basic_block reach_bb = walk_up ? e->src : e->dest;
if (e->flags & EDGE_DFS_BACK)
continue;
if (e->probability == profile_probability::never ()
|| e->count () == profile_count::zero ())
continue;
if (((reach_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != BB_COLD_PARTITION)
{
found = true;
break;
}
if (!(e->count () > highest_count))
highest_count = e->count ();
if (!highest_probability.initialized_p ()
|| e->probability > highest_probability)
highest_probability = e->probability;
}
if (found)
continue;
for ((ei) = ei_start_1 (&((edges))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
if (e->flags & EDGE_DFS_BACK)
continue;
if (e->probability == profile_probability::never ()
|| e->count () == profile_count::zero ())
continue;
if (highest_count.initialized_p ())
{
if (!(e->count () >= highest_count))
continue;
}
else if (!(e->probability >= highest_probability))
continue;
basic_block reach_bb = walk_up ? e->src : e->dest;
do { basic_block bb_ = (reach_bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (BB_HOT_PARTITION)); } while (0);
if (dump_file)
fprintf (dump_file, "Promoting bb %i to hot partition to sanitize "
"profile of bb %i in %s walk\n", reach_bb->index,
bb->index, walk_up ? "backward" : "forward");
cold_bb_count--;
bbs_in_hot_partition->safe_push (reach_bb);
hot_bbs_to_check.safe_push (reach_bb);
}
}
hot_bbs_to_check.release ();
return cold_bb_count;
}
static vec<edge>
find_rarely_executed_basic_blocks_and_crossing_edges (void)
{
vec<edge> crossing_edges = vNULL;
basic_block bb;
edge e;
edge_iterator ei;
unsigned int cold_bb_count = 0;
auto_vec<basic_block> bbs_in_hot_partition;
propagate_unlikely_bbs_forward ();
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
{
bool cold_bb = false;
if (probably_never_executed_bb_p ((cfun + 0), bb))
{
cold_bb = true;
if (!bb->count.precise_p ())
for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (!probably_never_executed_edge_p ((cfun + 0), e))
{
cold_bb = false;
break;
}
}
if (cold_bb)
{
do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (BB_COLD_PARTITION)); } while (0);
cold_bb_count++;
}
else
{
do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (BB_HOT_PARTITION)); } while (0);
bbs_in_hot_partition.safe_push (bb);
}
}
# 1707 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
if (cold_bb_count)
{
mark_dfs_back_edges ();
cold_bb_count = sanitize_hot_paths (true, cold_bb_count,
&bbs_in_hot_partition);
if (cold_bb_count)
sanitize_hot_paths (false, cold_bb_count, &bbs_in_hot_partition);
hash_set <basic_block> set;
find_bbs_reachable_by_hot_paths (&set);
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
if (!set.contains (bb))
do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (BB_COLD_PARTITION)); } while (0);
}
if ((cfun + 0)->eh->lp_array)
{
const bool sjlj
= (targetm_common.except_unwind_info (&global_options) == UI_SJLJ);
unsigned i;
eh_landing_pad lp;
for (i = 0; (*(cfun + 0)->eh->lp_array).iterate ((i), &(lp)); ++(i))
{
bool all_same, all_diff;
if (lp == nullptr
|| lp->landing_pad == (rtx) 0
|| !(((enum rtx_code) (lp->landing_pad)->code) == CODE_LABEL))
continue;
all_same = all_diff = true;
bb = BLOCK_FOR_INSN (lp->landing_pad);
for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
((void)(!(e->flags & EDGE_EH) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1745, __FUNCTION__), 0 : 0));
if (((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == ((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
all_diff = false;
else
all_same = false;
}
if (all_same)
;
else if (all_diff)
{
int which = ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
which ^= BB_HOT_PARTITION | BB_COLD_PARTITION;
do { basic_block bb_ = (bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (which)); } while (0);
}
else if (sjlj)
sjlj_fix_up_crossing_landing_pad (bb);
else
dw2_fix_up_crossing_landing_pad (lp, bb);
if (sjlj)
break;
}
}
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
unsigned int flags = e->flags;
((void)(!((flags & EDGE_CROSSING) == 0) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1778, __FUNCTION__), 0 : 0));
if (e->src != (((cfun + 0))->cfg->x_entry_block_ptr)
&& e->dest != (((cfun + 0))->cfg->x_exit_block_ptr)
&& ((e->src)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != ((e->dest)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))
{
crossing_edges.safe_push (e);
flags |= EDGE_CROSSING;
}
flags &= ~EDGE_PRESERVE;
e->flags = flags;
}
return crossing_edges;
}
static void
set_edge_can_fallthru_flag (void)
{
basic_block bb;
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
{
edge e;
edge_iterator ei;
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
{
e->flags &= ~EDGE_CAN_FALLTHRU;
if (e->flags & EDGE_FALLTHRU)
e->flags |= EDGE_CAN_FALLTHRU;
}
if (vec_safe_length (bb->succs) != 2)
continue;
if (!any_condjump_p ((bb)->il.x.rtl->end_))
continue;
rtx_jump_insn *bb_end_jump = as_a <rtx_jump_insn *> ((bb)->il.x.rtl->end_);
if (!invert_jump (bb_end_jump, (((bb_end_jump)->u.fld[7]).rt_rtx), 0))
continue;
invert_jump (bb_end_jump, (((bb_end_jump)->u.fld[7]).rt_rtx), 0);
(*(bb)->succs)[(0)]->flags |= EDGE_CAN_FALLTHRU;
(*(bb)->succs)[(1)]->flags |= EDGE_CAN_FALLTHRU;
}
}
static void
add_labels_and_missing_jumps (vec<edge> crossing_edges)
{
size_t i;
edge e;
for (i = 0; (crossing_edges).iterate ((i), &(e)); ++(i))
{
basic_block src = e->src;
basic_block dest = e->dest;
rtx_jump_insn *new_jump;
if (dest == (((cfun + 0))->cfg->x_exit_block_ptr))
continue;
rtx_code_label *label = block_label (dest);
if (src == (((cfun + 0))->cfg->x_entry_block_ptr))
continue;
if ((e->flags & EDGE_FALLTHRU) == 0)
continue;
if (control_flow_insn_p ((src)->il.x.rtl->end_))
continue;
((void)(!(single_succ_p (src)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 1870, __FUNCTION__), 0 : 0));
new_jump = emit_jump_insn_after (targetm.gen_jump (label), (src)->il.x.rtl->end_);
(src)->il.x.rtl->end_ = new_jump;
(((new_jump)->u.fld[7]).rt_rtx) = label;
(((label)->u.fld[4]).rt_int) += 1;
emit_barrier_after_bb (src);
e->flags &= ~EDGE_FALLTHRU;
}
}
# 1893 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
static void
fix_up_fall_thru_edges (void)
{
basic_block cur_bb;
for (cur_bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; cur_bb != ((cfun + 0))->cfg->x_exit_block_ptr; cur_bb = cur_bb->next_bb)
{
edge succ1;
edge succ2;
edge fall_thru = nullptr;
edge cond_jump = nullptr;
fall_thru = nullptr;
if (vec_safe_length (cur_bb->succs) > 0)
succ1 = (*(cur_bb)->succs)[(0)];
else
succ1 = nullptr;
if (vec_safe_length (cur_bb->succs) > 1)
succ2 = (*(cur_bb)->succs)[(1)];
else
succ2 = nullptr;
if (succ1
&& (succ1->flags & EDGE_FALLTHRU))
{
fall_thru = succ1;
cond_jump = succ2;
}
else if (succ2
&& (succ2->flags & EDGE_FALLTHRU))
{
fall_thru = succ2;
cond_jump = succ1;
}
else if (succ2 && vec_safe_length (cur_bb->succs) > 2)
fall_thru = find_fallthru_edge (cur_bb->succs);
if (fall_thru && (fall_thru->dest != (((cfun + 0))->cfg->x_exit_block_ptr)))
{
if (fall_thru->flags & EDGE_CROSSING)
{
bool cond_jump_crosses = true;
int invert_worked = 0;
rtx_insn *old_jump = (cur_bb)->il.x.rtl->end_;
if (cond_jump)
{
if (!(cond_jump->flags & EDGE_CROSSING))
cond_jump_crosses = false;
if (!cond_jump_crosses)
{
rtx_code_label *fall_thru_label
= block_label (fall_thru->dest);
if (old_jump && fall_thru_label)
{
rtx_jump_insn *old_jump_insn
= dyn_cast <rtx_jump_insn *> (old_jump);
if (old_jump_insn)
invert_worked = invert_jump (old_jump_insn,
fall_thru_label, 0);
}
if (invert_worked)
{
fall_thru->flags &= ~EDGE_FALLTHRU;
cond_jump->flags |= EDGE_FALLTHRU;
update_br_prob_note (cur_bb);
std::swap (fall_thru, cond_jump);
cond_jump->flags |= EDGE_CROSSING;
fall_thru->flags &= ~EDGE_CROSSING;
}
}
}
if (cond_jump_crosses || !invert_worked)
{
# 2000 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
fall_thru->flags &= ~EDGE_CROSSING;
basic_block new_bb = force_nonfallthru (fall_thru);
if (new_bb)
{
new_bb->aux = cur_bb->aux;
cur_bb->aux = new_bb;
((void)(!(((new_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) == ((cur_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2009, __FUNCTION__), 0 : 0))
;
single_succ_edge (new_bb)->flags |= EDGE_CROSSING;
}
else
{
fall_thru->flags |= EDGE_CROSSING;
}
emit_barrier_after_bb (new_bb ? new_bb : cur_bb);
}
}
}
}
}
static basic_block
find_jump_block (basic_block jump_dest)
{
basic_block source_bb = nullptr;
edge e;
rtx_insn *insn;
edge_iterator ei;
for ((ei) = ei_start_1 (&((jump_dest->preds))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->flags & EDGE_CROSSING)
{
basic_block src = e->src;
if ((((enum rtx_code) ((src)->il.x.head_)->code) == CODE_LABEL))
for (insn = (src)->il.x.head_;
!(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) == DEBUG_INSN)) && insn != NEXT_INSN ((src)->il.x.rtl->end_);
insn = NEXT_INSN (insn))
{
if ((((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) == DEBUG_INSN))
&& insn == (src)->il.x.rtl->end_
&& (((enum rtx_code) (insn)->code) == JUMP_INSN)
&& !any_condjump_p (insn))
{
source_bb = src;
break;
}
}
if (source_bb)
break;
}
return source_bb;
}
static void
fix_crossing_conditional_branches (void)
{
basic_block cur_bb;
basic_block new_bb;
basic_block dest;
edge succ1;
edge succ2;
edge crossing_edge;
edge new_edge;
rtx set_src;
rtx old_label = (rtx) 0;
rtx_code_label *new_label;
for (cur_bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; cur_bb != ((cfun + 0))->cfg->x_exit_block_ptr; cur_bb = cur_bb->next_bb)
{
crossing_edge = nullptr;
if (vec_safe_length (cur_bb->succs) > 0)
succ1 = (*(cur_bb)->succs)[(0)];
else
succ1 = nullptr;
if (vec_safe_length (cur_bb->succs) > 1)
succ2 = (*(cur_bb)->succs)[(1)];
else
succ2 = nullptr;
if (succ1 && (succ1->flags & EDGE_CROSSING))
crossing_edge = succ1;
else if (succ2 && (succ2->flags & EDGE_CROSSING))
crossing_edge = succ2;
if (crossing_edge)
{
rtx_insn *old_jump = (cur_bb)->il.x.rtl->end_;
set_src = (rtx) 0;
if (any_condjump_p (old_jump))
{
if (((enum rtx_code) (PATTERN (old_jump))->code) == SET)
set_src = (((PATTERN (old_jump))->u.fld[1]).rt_rtx);
else if (((enum rtx_code) (PATTERN (old_jump))->code) == PARALLEL)
{
set_src = (((((PATTERN (old_jump))->u.fld[0]).rt_rtvec))->elem[0]);
if (((enum rtx_code) (set_src)->code) == SET)
set_src = (((set_src)->u.fld[1]).rt_rtx);
else
set_src = (rtx) 0;
}
}
if (set_src && (((enum rtx_code) (set_src)->code) == IF_THEN_ELSE))
{
rtx_jump_insn *old_jump_insn =
as_a <rtx_jump_insn *> (old_jump);
if (((enum rtx_code) ((((set_src)->u.fld[1]).rt_rtx))->code) == PC)
old_label = (((set_src)->u.fld[2]).rt_rtx);
else if (((enum rtx_code) ((((set_src)->u.fld[2]).rt_rtx))->code) == PC)
old_label = (((set_src)->u.fld[1]).rt_rtx);
new_bb = find_jump_block (crossing_edge->dest);
if (new_bb)
new_label = block_label (new_bb);
else
{
basic_block last_bb;
rtx_code_label *old_jump_target;
rtx_jump_insn *new_jump;
new_label = gen_label_rtx ();
emit_label (new_label);
((void)(!(((enum rtx_code) (old_label)->code) == LABEL_REF) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2170, __FUNCTION__), 0 : 0));
old_jump_target = old_jump_insn->jump_target ();
new_jump = as_a <rtx_jump_insn *>
(emit_jump_insn (targetm.gen_jump (old_jump_target)));
new_jump->set_jump_target (old_jump_target);
last_bb = (((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb;
new_bb = create_basic_block (new_label, new_jump, last_bb);
new_bb->aux = last_bb->aux;
last_bb->aux = new_bb;
emit_barrier_after_bb (new_bb);
do { basic_block bb_ = (new_bb); bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) | (((cur_bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)))); } while (0);
}
redirect_jump (old_jump_insn, new_label, 0);
dest = crossing_edge->dest;
redirect_edge_succ (crossing_edge, new_bb);
if (vec_safe_length (new_bb->succs) == 0)
new_edge = make_single_succ_edge (new_bb, dest, 0);
else
new_edge = (*(new_bb)->succs)[(0)];
crossing_edge->flags &= ~EDGE_CROSSING;
new_edge->flags |= EDGE_CROSSING;
}
}
}
}
static void
fix_crossing_unconditional_branches (void)
{
basic_block cur_bb;
rtx_insn *last_insn;
rtx label;
rtx label_addr;
rtx_insn *indirect_jump_sequence;
rtx_insn *jump_insn = nullptr;
rtx new_reg;
rtx_insn *cur_insn;
edge succ;
for (cur_bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; cur_bb != ((cfun + 0))->cfg->x_exit_block_ptr; cur_bb = cur_bb->next_bb)
{
last_insn = (cur_bb)->il.x.rtl->end_;
if (vec_safe_length (cur_bb->succs) < 1)
continue;
succ = (*(cur_bb)->succs)[(0)];
if ((((enum rtx_code) (last_insn)->code) == JUMP_INSN)
&& (succ->flags & EDGE_CROSSING))
{
((void)(!(!any_condjump_p (last_insn)) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2245, __FUNCTION__), 0 : 0));
if (!computed_jump_p (last_insn)
&& !tablejump_p (last_insn, nullptr, nullptr))
{
label = (((last_insn)->u.fld[7]).rt_rtx);
label_addr = gen_rtx_fmt_u_stat ((LABEL_REF), (((global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))))), ((label)) );
(((label)->u.fld[4]).rt_int) += 1;
new_reg = gen_reg_rtx ((global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))));
start_sequence ();
emit_move_insn (new_reg, label_addr);
emit_indirect_jump (new_reg);
indirect_jump_sequence = get_insns ();
end_sequence ();
for (cur_insn = indirect_jump_sequence; cur_insn;
cur_insn = NEXT_INSN (cur_insn))
{
if (!(((enum rtx_code) (cur_insn)->code) == BARRIER))
BLOCK_FOR_INSN (cur_insn) = cur_bb;
if ((((enum rtx_code) (cur_insn)->code) == JUMP_INSN))
jump_insn = cur_insn;
}
emit_insn_before (indirect_jump_sequence, last_insn);
delete_insn (last_insn);
(((jump_insn)->u.fld[7]).rt_rtx) = label;
(((label)->u.fld[4]).rt_int)++;
(cur_bb)->il.x.rtl->end_ = jump_insn;
}
}
}
}
static void
update_crossing_jump_flags (void)
{
basic_block bb;
edge e;
edge_iterator ei;
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e)); ei_next (&(ei)))
if (e->flags & EDGE_CROSSING)
{
if ((((enum rtx_code) ((bb)->il.x.rtl->end_)->code) == JUMP_INSN))
(__extension__ ({ __typeof (((bb)->il.x.rtl->end_)) const _rtx = (((bb)->il.x.rtl->end_)); if (((enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2316, __FUNCTION__); _rtx; })->jump) = 1;
break;
}
}
static void
reorder_basic_blocks_software_trace_cache (void)
{
if (dump_file)
fprintf (dump_file, "\nReordering with the STC algorithm.\n\n");
int n_traces;
int i;
struct trace *traces;
if ((this_target_bb_reorder->x_uncond_jump_length) == 0)
(this_target_bb_reorder->x_uncond_jump_length) = get_uncond_jump_length ();
array_size = (((((((cfun + 0))->cfg->x_last_basic_block)) / 4) + 1) * 5);
bbd = ((bbro_basic_block_data *) xmalloc (sizeof (bbro_basic_block_data) * (array_size)));
for (i = 0; i < array_size; i++)
{
bbd[i].start_of_trace = -1;
bbd[i].end_of_trace = -1;
bbd[i].in_trace = -1;
bbd[i].visited = 0;
bbd[i].priority = -1;
bbd[i].heap = nullptr;
bbd[i].node = nullptr;
}
traces = ((struct trace *) xmalloc (sizeof (struct trace) * ((((cfun + 0))->cfg->x_n_basic_blocks))));
n_traces = 0;
find_traces (&n_traces, traces);
connect_traces (n_traces, traces);
(((void)(!(traces) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2356, __FUNCTION__), 0 : 0)), free (traces), traces = 0);
(((void)(!(bbd) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2357, __FUNCTION__), 0 : 0)), free (bbd), bbd = 0);
}
static int
edge_order (const void *ve1, const void *ve2)
{
edge e1 = *(const edge *) ve1;
edge e2 = *(const edge *) ve2;
profile_count c1 = e1->count ();
profile_count c2 = e2->count ();
profile_count m = c1.max (c2);
return (m == c2) - (m == c1);
}
static void
reorder_basic_blocks_simple (void)
{
if (dump_file)
fprintf (dump_file, "\nReordering with the \"simple\" algorithm.\n\n");
edge *edges = new edge[2 * (((cfun + 0))->cfg->x_n_basic_blocks)];
int n = 0;
edges[n++] = (*((((cfun + 0))->cfg->x_entry_block_ptr))->succs)[(0)];
basic_block bb;
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
{
rtx_insn *end = (bb)->il.x.rtl->end_;
if (computed_jump_p (end) || tablejump_p (end, nullptr, nullptr))
continue;
if ((((enum rtx_code) (end)->code) == JUMP_INSN) && extract_asm_operands (end))
continue;
if (single_succ_p (bb))
edges[n++] = (*(bb)->succs)[(0)];
else if (any_condjump_p (end))
{
edge e0 = (*(bb)->succs)[(0)];
edge e1 = (*(bb)->succs)[(1)];
if (e1->flags & EDGE_FALLTHRU)
std::swap (e0, e1);
edges[n++] = e0;
edges[n++] = e1;
}
}
if (optimize_function_for_speed_p ((cfun + 0)))
gcc_stablesort (edges, n, sizeof *edges, edge_order);
# 2436 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
for (bb = (((cfun + 0))->cfg->x_entry_block_ptr); bb; bb = bb->next_bb)
{
bb->aux = bb;
bb->flags &= ~BB_VISITED;
}
(((cfun + 0))->cfg->x_exit_block_ptr)->aux = 0;
for (int j = 0; j < n; j++)
{
edge e = edges[j];
basic_block tail_a = e->src;
basic_block head_b = e->dest;
basic_block head_a = (basic_block) tail_a->aux;
basic_block tail_b = (basic_block) head_b->aux;
if (e->flags & EDGE_CROSSING
|| tail_a->flags & BB_VISITED
|| !tail_b
|| (!(head_b->flags & BB_VISITED) && head_b != tail_b)
|| tail_a == tail_b)
{
edges[j] = 0;
continue;
}
tail_a->aux = 0;
head_b->aux = 0;
head_a->aux = tail_b;
tail_b->aux = head_a;
tail_a->flags |= BB_VISITED;
}
basic_block last_tail = (basic_block) (((cfun + 0))->cfg->x_entry_block_ptr)->aux;
int current_partition
= ((last_tail == (((cfun + 0))->cfg->x_entry_block_ptr) ? (*((((cfun + 0))->cfg->x_entry_block_ptr))->succs)[(0)]->dest : last_tail)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
;
bool need_another_pass = true;
for (int pass = 0; pass < 2 && need_another_pass; pass++)
{
need_another_pass = false;
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
if ((bb->flags & BB_VISITED && bb->aux) || bb->aux == bb)
{
if (((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != current_partition)
{
need_another_pass = true;
continue;
}
last_tail->aux = bb;
last_tail = (basic_block) bb->aux;
}
current_partition ^= BB_HOT_PARTITION | BB_COLD_PARTITION;
}
last_tail->aux = 0;
for (int j = 0; j < n; j++)
if (edges[j])
edges[j]->src->aux = edges[j]->dest;
delete[] edges;
edge e = (*((((cfun + 0))->cfg->x_entry_block_ptr))->succs)[(0)];
if (e->dest != (((cfun + 0))->cfg->x_entry_block_ptr)->aux)
{
force_nonfallthru (e);
e->src->aux = (((cfun + 0))->cfg->x_entry_block_ptr)->aux;
}
}
static void
reorder_basic_blocks (void)
{
((void)(!(current_ir_type () == IR_RTL_CFGLAYOUT) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2540, __FUNCTION__), 0 : 0));
if ((((cfun + 0))->cfg->x_n_basic_blocks) <= (2) + 1)
return;
set_edge_can_fallthru_flag ();
mark_dfs_back_edges ();
switch (global_options.x_flag_reorder_blocks_algorithm)
{
case REORDER_BLOCKS_ALGORITHM_SIMPLE:
reorder_basic_blocks_simple ();
break;
case REORDER_BLOCKS_ALGORITHM_STC:
reorder_basic_blocks_software_trace_cache ();
break;
default:
(fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2559, __FUNCTION__));
}
relink_block_chain ( true);
if (dump_file)
{
if (dump_flags & TDF_DETAILS)
dump_reg_info (dump_file);
dump_flow_info (dump_file, dump_flags);
}
(&x_rtl)->bb_reorder_complete = true;
}
# 2584 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
void
insert_section_boundary_note (void)
{
basic_block bb;
bool switched_sections = false;
int current_partition = 0;
if (!(&x_rtl)->has_bb_partition)
return;
for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->next_bb)
{
if (!current_partition)
current_partition = ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
if (((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) != current_partition)
{
((void)(!(!switched_sections) ? fancy_abort ("/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2600, __FUNCTION__), 0 : 0));
switched_sections = true;
emit_note_before (NOTE_INSN_SWITCH_TEXT_SECTIONS, (bb)->il.x.head_);
current_partition = ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION));
}
}
(&x_rtl)->has_bb_partition = switched_sections;
}
namespace {
const pass_data pass_data_reorder_blocks =
{
RTL_PASS,
"bbro",
OPTGROUP_NONE,
TV_REORDER_BLOCKS,
0,
0,
0,
0,
0,
};
class pass_reorder_blocks : public rtl_opt_pass
{
public:
pass_reorder_blocks (gcc::context *ctxt)
: rtl_opt_pass (pass_data_reorder_blocks, ctxt)
{}
virtual bool gate (function *)
{
if (targetm.cannot_modify_jumps_p ())
return false;
return (global_options.x_optimize > 0
&& (global_options.x_flag_reorder_blocks || global_options.x_flag_reorder_blocks_and_partition));
}
virtual unsigned int execute (function *);
};
unsigned int
pass_reorder_blocks::execute (function *fun)
{
basic_block bb;
cfg_layout_initialize (1);
reorder_basic_blocks ();
cleanup_cfg (1 | 128);
for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
if (bb->next_bb != ((fun)->cfg->x_exit_block_ptr))
bb->aux = bb->next_bb;
cfg_layout_finalize ();
for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
df_recompute_luids (bb);
return 0;
}
}
rtl_opt_pass *
make_pass_reorder_blocks (gcc::context *ctxt)
{
return new pass_reorder_blocks (ctxt);
}
static bool
maybe_duplicate_computed_goto (basic_block bb, int max_size)
{
if (single_pred_p (bb))
return false;
rtx_insn *insn;
for ((insn) = (bb)->il.x.head_; (insn) && (insn) != NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (insn))
if ((((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) == DEBUG_INSN)))
{
max_size -= get_attr_min_length (insn);
if (max_size < 0)
return false;
}
bool changed = false;
edge e;
edge_iterator ei;
for (ei = ei_start_1 (&(bb->preds)); (e = ei_safe_edge (ei)); )
{
basic_block pred = e->src;
if (single_pred_p (bb)
|| !single_succ_p (pred)
|| e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)
|| pred->index < (2)
|| ((((enum rtx_code) ((pred)->il.x.rtl->end_)->code) == JUMP_INSN) && !simplejump_p ((pred)->il.x.rtl->end_))
|| ((((enum rtx_code) ((pred)->il.x.rtl->end_)->code) == JUMP_INSN) && (__extension__ ({ __typeof (((pred)->il.x.rtl->end_)) const _rtx = (((pred)->il.x.rtl->end_)); if (((enum rtx_code) (_rtx)->code) != JUMP_INSN) rtl_check_failed_flag ("CROSSING_JUMP_P", _rtx, "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2710, __FUNCTION__); _rtx; })->jump)))
{
ei_next (&ei);
continue;
}
if (dump_file)
fprintf (dump_file, "Duplicating computed goto bb %d into bb %d\n",
bb->index, e->src->index);
bool can_dup_more = can_duplicate_block_p (pred);
basic_block copy = duplicate_block (bb, e, nullptr);
emit_barrier_after_bb (copy);
reorder_insns_nobb ((copy)->il.x.head_, (copy)->il.x.rtl->end_, (pred)->il.x.rtl->end_);
merge_blocks (pred, copy);
changed = true;
if (can_dup_more)
maybe_duplicate_computed_goto (pred, max_size);
}
return changed;
}
static void
duplicate_computed_gotos (function *fun)
{
if ((this_target_bb_reorder->x_uncond_jump_length) == 0)
(this_target_bb_reorder->x_uncond_jump_length) = get_uncond_jump_length ();
int max_size
= (this_target_bb_reorder->x_uncond_jump_length) * global_options.x_param_max_goto_duplication_insns;
bool changed = false;
basic_block bb;
for (bb = (fun)->cfg->x_entry_block_ptr->next_bb; bb != (fun)->cfg->x_exit_block_ptr; bb = bb->next_bb)
if (computed_jump_p ((bb)->il.x.rtl->end_) && can_duplicate_block_p (bb))
changed |= maybe_duplicate_computed_goto (bb, max_size);
if (changed)
fixup_partitions ();
}
namespace {
const pass_data pass_data_duplicate_computed_gotos =
{
RTL_PASS,
"compgotos",
OPTGROUP_NONE,
TV_REORDER_BLOCKS,
0,
0,
0,
0,
0,
};
class pass_duplicate_computed_gotos : public rtl_opt_pass
{
public:
pass_duplicate_computed_gotos (gcc::context *ctxt)
: rtl_opt_pass (pass_data_duplicate_computed_gotos, ctxt)
{}
virtual bool gate (function *);
virtual unsigned int execute (function *);
};
bool
pass_duplicate_computed_gotos::gate (function *fun)
{
if (targetm.cannot_modify_jumps_p ())
return false;
return (global_options.x_optimize > 0
&& global_options.x_flag_expensive_optimizations
&& ! optimize_function_for_size_p (fun));
}
unsigned int
pass_duplicate_computed_gotos::execute (function *fun)
{
duplicate_computed_gotos (fun);
return 0;
}
}
rtl_opt_pass *
make_pass_duplicate_computed_gotos (gcc::context *ctxt)
{
return new pass_duplicate_computed_gotos (ctxt);
}
# 2917 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
namespace {
const pass_data pass_data_partition_blocks =
{
RTL_PASS,
"bbpart",
OPTGROUP_NONE,
TV_REORDER_BLOCKS,
(1 << 9),
0,
0,
0,
0,
};
class pass_partition_blocks : public rtl_opt_pass
{
public:
pass_partition_blocks (gcc::context *ctxt)
: rtl_opt_pass (pass_data_partition_blocks, ctxt)
{}
virtual bool gate (function *);
virtual unsigned int execute (function *);
};
bool
pass_partition_blocks::gate (function *fun)
{
return (global_options.x_flag_reorder_blocks_and_partition
&& global_options.x_optimize
&& optimize_function_for_speed_p (fun)
&& !decl_comdat_group (current_function_decl)
&& !lookup_attribute ("section", ((contains_struct_check ((fun->decl), (TS_DECL_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2958, __FUNCTION__))->decl_common.attributes))
&& !lookup_attribute ("naked", ((contains_struct_check ((fun->decl), (TS_DECL_COMMON), "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2959, __FUNCTION__))->decl_common.attributes))
&& !(global_options.x_in_lto_p && ((tree_check ((((contains_struct_check ((fun->decl), (TS_DECL_MINIMAL), "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2962, __FUNCTION__))->decl_minimal.name)), "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c", 2962, __FUNCTION__, (IDENTIFIER_NODE))) == global_trees[TI_MAIN_IDENTIFIER])));
}
unsigned
pass_partition_blocks::execute (function *fun)
{
vec<edge> crossing_edges;
if (((fun)->cfg->x_n_basic_blocks) <= (2) + 1)
return 0;
df_set_flags (DF_DEFER_INSN_RESCAN);
crossing_edges = find_rarely_executed_basic_blocks_and_crossing_edges ();
if (!crossing_edges.exists ())
return (1 << 17);
(&x_rtl)->has_bb_partition = true;
add_labels_and_missing_jumps (crossing_edges);
fix_up_fall_thru_edges ();
if (!1)
fix_crossing_conditional_branches ();
if (!1)
fix_crossing_unconditional_branches ();
update_crossing_jump_flags ();
clear_aux_for_blocks ();
crossing_edges.release ();
# 3032 "/home/giulianob/gcc_git_gnu/gcc/gcc/bb-reorder.c"
if (fun->eh->lp_array)
{
df_finish_pass (true);
df_scan_alloc (nullptr);
df_scan_blocks ();
df_set_flags (DF_LR_RUN_DCE);
df_analyze ();
}
return (1 << 17);
}
}
rtl_opt_pass *
make_pass_partition_blocks (gcc::context *ctxt)
{
return new pass_partition_blocks (ctxt);
}
| [
"giuliano.belinassi@usp.br"
] | giuliano.belinassi@usp.br |
41731aa2894b2cfd8884c67eee8ec18159d26f2e | cfccf529f96a26e70b7d5d9841017ca53179d19c | /EditScene.cpp | 6c995c32f48f89eecfe3a961376a7ad76f9fbc86 | [] | no_license | bingwan/Cut2.1.2Classes | 68a9fc145bd0b1c826d34ef504dc51176fac2579 | 11cd9bf38c1c03cf0039a9f6f934ba46e27d2f86 | refs/heads/master | 2020-06-30T04:05:53.313789 | 2014-07-16T04:55:33 | 2014-07-16T04:55:33 | 21,887,351 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 719 | cpp |
#include "EditScene.h"
#include "CCMenuItemButton.h"
#include "CCSceneManager.h"
#include "EditLayer.h"
#include "CCAPI.h"
USING_NS_CC;
EditScene::EditScene()
{
}
EditScene::~EditScene()
{
}
bool EditScene::init()
{
if (!CCScene::init())
{
return false;
}
return true;
}
void EditScene::onEnter()
{
CCScene::onEnter();
CCSize winSize = CCDirector::sharedDirector()->getWinSize();
//CCSize appSize = gCCAPIPtr->getAppSize();
CCSize contentSize = getContentSize();
EditLayer* pLayer = EditLayer::create(ccc4(100, 100, 0,255),winSize.width,winSize.height);
pLayer->setAnchorPoint(ccp(0,0));
pLayer->setPosition(ccp(0,0));
addChild(pLayer);
} | [
"780319771@qq.com"
] | 780319771@qq.com |
a3db026604e4d0ee2897e97c5e1111c626c7175b | 88d7a36bd0efe944867dafbbe0fd886eb904806a | /src/wallet/api/transaction_info.cpp | 531a5763ecb912da9799158006aaa396380aa2df | [
"BSD-3-Clause"
] | permissive | tngamemo/sumokoin | aedd76d7d19760a95fc69e3e0b132a629a2061d5 | 29123773affd42a1dd7a09f7d07cc88dad865011 | refs/heads/master | 2021-07-22T21:08:48.464250 | 2017-10-17T05:43:47 | 2017-10-17T05:43:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,014 | cpp | // Copyright (c) 2016-2017, SUMOKOIN, (forked from) The Monero Project
//
// 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.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include "transaction_info.h"
using namespace std;
namespace Monero {
TransactionInfo::~TransactionInfo() {}
TransactionInfo::Transfer::Transfer(uint64_t _amount, const string &_address)
: amount(_amount), address(_address) {}
TransactionInfoImpl::TransactionInfoImpl()
: m_direction(Direction_Out)
, m_pending(false)
, m_failed(false)
, m_amount(0)
, m_fee(0)
, m_blockheight(0)
, m_timestamp(0)
{
}
TransactionInfoImpl::~TransactionInfoImpl()
{
}
int TransactionInfoImpl::direction() const
{
return m_direction;
}
bool TransactionInfoImpl::isPending() const
{
return m_pending;
}
bool TransactionInfoImpl::isFailed() const
{
return m_failed;
}
uint64_t TransactionInfoImpl::amount() const
{
return m_amount;
}
uint64_t TransactionInfoImpl::fee() const
{
return m_fee;
}
uint64_t TransactionInfoImpl::blockHeight() const
{
return m_blockheight;
}
string TransactionInfoImpl::hash() const
{
return m_hash;
}
std::time_t TransactionInfoImpl::timestamp() const
{
return m_timestamp;
}
string TransactionInfoImpl::paymentId() const
{
return m_paymentid;
}
const std::vector<TransactionInfo::Transfer> &TransactionInfoImpl::transfers() const
{
return m_transfers;
}
} // namespace
namespace Bitmonero = Monero;
| [
"sumoshi.tanaka@gmail.com"
] | sumoshi.tanaka@gmail.com |
39d0250fe69e69a45207917a1766c7fab0562d5a | bfd8cc884be8a8e89cb4ac434eaa7b3d0c3c0255 | /Assignment 4/structure.cpp | c98d0ebd3046ff84d832a759fa9737251ce29117 | [] | no_license | edwin03/OSU-CS162 | f7eb2ce58848fbefe16a0c38fbacf0e5bee5553f | 494f157a4d017834665d76e00cb9039b6cd2faf5 | refs/heads/master | 2021-01-10T12:28:09.928387 | 2016-03-16T15:33:41 | 2016-03-16T15:33:41 | 52,890,632 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,086 | cpp | /**************************************************************************
** File Name: structure.cpp
** Author: Edwin Rubio
** Date: 02/28/2016
** Description: structure.cpp is the implementation file for structure.hpp
***************************************************************************/
#include <iostream>
#include "structure.hpp"
#include "Creature.hpp"
/*********************************************************************
** Function: remove()
** Description: takes off the object on top of the stack.
** Parameters: None
*********************************************************************/
Creature* Structure::remove()
{
Node *nodePtr;
Creature *c;
nodePtr = head;
c = head->player;
head = head->next;
delete nodePtr;
return c;
}
/*********************************************************************
** Function: isEmpty()
** Description: indicates if the list is empty.
** Parameters: None
*********************************************************************/
bool Structure::isEmpty()
{
return head == NULL;
}
| [
"edwin.rubio@ymail.com"
] | edwin.rubio@ymail.com |
391f283b92efa83ba213ab51cb4b3a0b1872018a | ff059e4fb3f5c55d75d9257b33d6dfa8298cbff9 | /include/utils4cpp/str/UStringGlobal.hpp | 573f64a034e02e45342cf42fb175069ebde51036 | [
"BSD-3-Clause"
] | permissive | BigTrotterZ/utils4cpp | 134b5d07aeb1126621ad5b2f71af841b1d7a1a92 | 0e9ebd791aee22fe93c42fdd706443180e1c1e01 | refs/heads/master | 2020-09-22T15:56:43.166158 | 2019-11-30T20:41:43 | 2019-11-30T20:41:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,893 | hpp | /************************************************************************************
**
** BSD 3-Clause License
**
** Copyright (c) 2019, shaoguang. 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.
**
************************************************************************************/
#ifndef UTILS4CPP_STR_USTRINGGLOBAL_HPP
#define UTILS4CPP_STR_USTRINGGLOBAL_HPP
#include <cwchar>
#include <cuchar>
#include <locale>
#include <string>
#include <string_view>
#include "utils4cpp/core/UCore.hpp"
#include "utils4cpp/core/UTypeTraits.hpp"
namespace utils4cpp::str {
/** Indicates case sensitive or not. */
enum UCaseSensitivity {
UCaseInsensitive, ///< Case insensitive. (no)
UCaseSensitive ///< Case sensitive. (yes)
};
/**
Swap char \a a and \a b with no intermediate variable.
*/
template<typename CharT>
inline void uSwapChar(CharT &a, CharT& b) noexcept
{
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
//
// convertible to stl-style string traits
//
template<class StringT>
using is_convertible_to_stlstyle_string = u_and<
std::is_convertible<const StringT&, std::basic_string<
typename StringT::value_type, typename StringT::traits_type, typename StringT::allocator_type>>,
u_not<std::is_convertible<const StringT&, const typename StringT::value_type *>>>;
template<class StringT>
inline constexpr bool is_convertible_to_stlstyle_string_v = is_convertible_to_stlstyle_string<StringT>::value;
template<class StringT>
using if_convertible_to_stlstyle_string = std::enable_if_t<
is_convertible_to_stlstyle_string_v<StringT>, primitive_t<StringT>>;
namespace detail {
template<class StringT, class CharT>
using _is_stlstyle_string = u_and<
std::is_same<typename StringT::value_type, CharT>,
std::is_same<StringT, std::basic_string<
typename StringT::value_type,
typename StringT::traits_type,
typename StringT::allocator_type>>>;
template<class StringT, class CharT>
inline constexpr bool _is_stlstyle_string_v = _is_stlstyle_string<StringT, CharT>::value;
template<class StringT, class CharT>
using _if_stlstyle_string = std::enable_if_t<_is_stlstyle_string_v<StringT, CharT>, StringT>;
} // namespace utils4cpp::str::detail
//
// std::basic_string traits
//
template<class StringT>
using is_std_basic_string = detail::_is_stlstyle_string<StringT, typename StringT::value_type>;
template<class StringT>
inline constexpr bool is_std_basic_string_v = is_std_basic_string<StringT>::value;
template<class StringT>
using if_std_basic_string = std::enable_if_t<is_std_basic_string_v<StringT>, StringT>;
//
// std char string traits
//
template<class StringT>
using is_std_char_string = detail::_is_stlstyle_string<StringT, char>;
template<class StringT>
inline constexpr bool is_std_char_string_v = is_std_char_string<StringT>::value;
template<class StringT>
using if_std_char_string = std::enable_if_t<is_std_char_string_v<StringT>, StringT>;
//
// std wchar_t string traits
//
template<class StringT>
using is_std_wchar_string = detail::_is_stlstyle_string<StringT, wchar_t>;
template<class StringT>
inline constexpr bool is_std_wchar_string_v = is_std_wchar_string<StringT>::value;
template<class StringT>
using if_std_wchar_string = std::enable_if_t<is_std_wchar_string_v<StringT>, StringT>;
//
// std char16 string traits
//
template<class StringT>
using is_std_char16_string = detail::_is_stlstyle_string<StringT, char16_t>;
template<class StringT>
inline constexpr bool is_std_char16_string_v = is_std_char16_string<StringT>::value;
template<class StringT>
using if_std_char16_string = std::enable_if_t<is_std_char16_string_v<StringT>, StringT>;
//
// std char32 string traits
//
template<class StringT>
using is_std_char32_string = detail::_is_stlstyle_string<StringT, char32_t>;
template<class StringT>
inline constexpr bool is_std_char32_string_v = is_std_char32_string<StringT>::value;
template<class StringT>
using if_std_char32_string = std::enable_if_t<is_std_char32_string_v<StringT>, StringT>;
//
// std char8_t string traits
//
#if UTILS4CPP_HAS_CHAR8T
template<class StringT>
using is_std_char8_string = detail::_is_stlstyle_string<StringT, char8_t>;
template<class StringT>
inline constexpr bool is_std_char8_string_v = is_std_char8_string<StringT>::value;
template<class StringT>
using if_std_char8_string = std::enable_if_t<is_std_char8_string_v<StringT>, StringT>;
//
// std char string or std char8_t string traits
//
template<class StringT>
using is_std_char_or_char8_string = u_or<is_std_char_string<StringT>, is_std_char8_string<StringT>>;
template<class StringT>
inline constexpr bool is_std_char_or_char8_string_v = is_std_char_or_char8_string<StringT>::value;
template<class StringT>
using if_std_char_or_char8_string = std::enable_if_t<is_std_char_or_char8_string_v<StringT>, StringT>;
#endif // UTILS4CPP_HAS_CHAR8T
//
// std char string or std wchar_t string traits
//
template<class StringT>
using is_std_char_or_wchar_string = u_or<is_std_char_string<StringT>, is_std_wchar_string<StringT>>;
template<class StringT>
inline constexpr bool is_std_char_or_wchar_string_v = is_std_char_or_wchar_string<StringT>::value;
template<class StringT>
using if_std_char_or_wchar_string = std::enable_if_t<is_std_char_or_wchar_string_v<StringT>, StringT>;
} // namespace utils4cpp::str
#endif // UTILS4CPP_STR_USTRINGGLOBAL_HPP | [
"1157656040@qq.com"
] | 1157656040@qq.com |
24082d729796447ee3ecd06076baa71e95b16db0 | 516899d0e784436660743b8151af6ba61dd89068 | /EmuCHIP-8/Cpu.h | eebe53f89045e10cafd6e9fa07fda479765bddf2 | [] | no_license | HeyItsJon/emuCHIP-8 | 0072743abc563bb778f6f3c6b444f8f2895abb12 | 33d279d80de71e926cb89627ca0dce2d4ec1339b | refs/heads/master | 2020-03-27T05:28:20.334885 | 2018-08-28T12:11:02 | 2018-08-28T12:11:02 | 146,022,633 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,165 | h | #pragma once
#include <vector>
using std::vector;
#include "SDL.h"
// Macros
#define GET_BYTE(x,y) (x >> (y*8) & 0xFF)
#define GET_NIBBLE(x,y) (x >> (y*4) & 0xF)
#define GET_NNN(x) (x & 0xFFF)
// Useful constants
const unsigned int W = 64, H = 32;
#define MEMORY_BEGIN 0x200
#define FONT_BEGIN 0x50
#define SPRITE_WIDTH 8
#define NUMBER_OF_KEYS 16
#define DISPLAY_SIZE (W*H/8)
// Set random number range to 0-255
#ifdef RAND_MAX
#undef RAND_MAX
#endif
#define RAND_MAX 255
class Cpu
{
private:
// 4K of memory
unsigned char memory[4096];
// 16 8-bit data registers
unsigned char V[16];
// Address register
unsigned short I;
// Program counter
unsigned short pc;
// Stack
vector<short> stack;
// Delay timer - count down at 60Hz
unsigned char delayTimer;
// 64*32 pixel monochrome display - each bit represents one pixel: 0 = black, 1 = white
unsigned char display[DISPLAY_SIZE];
public:
Cpu();
~Cpu();
// Hex keyboard input
unsigned char keys[NUMBER_OF_KEYS];
// Sound timer - count down at 60Hz
unsigned char soundTimer;
int Execute();
bool LoadMemory(string);
int Init();
void UpdateTimers();
void RenderTo(unsigned int[]);
};
| [
"jaltenbu@gmail.com"
] | jaltenbu@gmail.com |
ea0f7c79a107b607c333a45bef9542424bc64bcd | 1d928c3f90d4a0a9a3919a804597aa0a4aab19a3 | /c++/xbmc/2017/4/FileItem.cpp | 1eb38078ea546b69c6c78f3b19e3d8d6dd33b754 | [] | no_license | rosoareslv/SED99 | d8b2ff5811e7f0ffc59be066a5a0349a92cbb845 | a062c118f12b93172e31e8ca115ce3f871b64461 | refs/heads/main | 2023-02-22T21:59:02.703005 | 2021-01-28T19:40:51 | 2021-01-28T19:40:51 | 306,497,459 | 1 | 1 | null | 2020-11-24T20:56:18 | 2020-10-23T01:18:07 | null | UTF-8 | C++ | false | false | 94,534 | cpp | /*
* Copyright (C) 2005-2015 Team Kodi
* http://kodi.tv
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Kodi; see the file COPYING. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#include <cstdlib>
#include "FileItem.h"
#include "ServiceBroker.h"
#include "guilib/LocalizeStrings.h"
#include "utils/StringUtils.h"
#include "utils/URIUtils.h"
#include "utils/Archive.h"
#include "Util.h"
#include "playlists/PlayListFactory.h"
#include "utils/Crc32.h"
#include "filesystem/Directory.h"
#include "filesystem/File.h"
#include "filesystem/StackDirectory.h"
#include "filesystem/CurlFile.h"
#include "filesystem/MultiPathDirectory.h"
#include "filesystem/MusicDatabaseDirectory.h"
#include "filesystem/VideoDatabaseDirectory.h"
#include "filesystem/VideoDatabaseDirectory/QueryParams.h"
#include "games/addons/GameClient.h"
#include "games/GameUtils.h"
#include "games/tags/GameInfoTag.h"
#include "music/tags/MusicInfoTagLoaderFactory.h"
#include "CueDocument.h"
#include "video/VideoDatabase.h"
#include "music/MusicDatabase.h"
#include "pvr/channels/PVRChannel.h"
#include "pvr/channels/PVRRadioRDSInfoTag.h"
#include "pvr/epg/Epg.h"
#include "pvr/recordings/PVRRecording.h"
#include "pvr/timers/PVRTimerInfoTag.h"
#include "video/Bookmark.h"
#include "video/VideoInfoTag.h"
#include "threads/SingleLock.h"
#include "music/tags/MusicInfoTag.h"
#include "pictures/PictureInfoTag.h"
#include "music/Artist.h"
#include "music/Album.h"
#include "URL.h"
#include "settings/AdvancedSettings.h"
#include "settings/Settings.h"
#include "utils/RegExp.h"
#include "utils/log.h"
#include "utils/Variant.h"
#include "utils/Mime.h"
#include "utils/Random.h"
#include "events/IEvent.h"
#include <assert.h>
#include <algorithm>
using namespace XFILE;
using namespace PLAYLIST;
using namespace MUSIC_INFO;
using namespace PVR;
using namespace GAME;
CFileItem::CFileItem(const CSong& song)
{
Initialize();
SetFromSong(song);
}
CFileItem::CFileItem(const CSong& song, const CMusicInfoTag& music)
{
Initialize();
SetFromSong(song);
*GetMusicInfoTag() = music;
}
CFileItem::CFileItem(const CURL &url, const CAlbum& album)
{
Initialize();
m_strPath = url.Get();
URIUtils::AddSlashAtEnd(m_strPath);
SetFromAlbum(album);
}
CFileItem::CFileItem(const std::string &path, const CAlbum& album)
{
Initialize();
m_strPath = path;
URIUtils::AddSlashAtEnd(m_strPath);
SetFromAlbum(album);
}
CFileItem::CFileItem(const CMusicInfoTag& music)
{
Initialize();
SetLabel(music.GetTitle());
m_strPath = music.GetURL();
m_bIsFolder = URIUtils::HasSlashAtEnd(m_strPath);
*GetMusicInfoTag() = music;
FillInDefaultIcon();
FillInMimeType(false);
}
CFileItem::CFileItem(const CVideoInfoTag& movie)
{
Initialize();
SetFromVideoInfoTag(movie);
}
CFileItem::CFileItem(const CPVREpgInfoTagPtr& tag)
{
assert(tag.get());
Initialize();
m_bIsFolder = false;
m_epgInfoTag = tag;
m_strPath = tag->Path();
SetLabel(tag->Title());
m_strLabel2 = tag->Plot();
m_dateTime = tag->StartAsLocalTime();
if (!tag->Icon().empty())
SetIconImage(tag->Icon());
else if (tag->HasPVRChannel() && !tag->ChannelTag()->IconPath().empty())
SetIconImage(tag->ChannelTag()->IconPath());
FillInMimeType(false);
}
CFileItem::CFileItem(const CPVRChannelPtr& channel)
{
assert(channel.get());
Initialize();
CPVREpgInfoTagPtr epgNow(channel->GetEPGNow());
m_strPath = channel->Path();
m_bIsFolder = false;
m_pvrChannelInfoTag = channel;
SetLabel(channel->ChannelName());
m_strLabel2 = epgNow ? epgNow->Title() :
CServiceBroker::GetSettings().GetBool(CSettings::SETTING_EPG_HIDENOINFOAVAILABLE) ?
"" : g_localizeStrings.Get(19055); // no information available
if (channel->IsRadio())
{
CMusicInfoTag* musictag = GetMusicInfoTag();
if (musictag)
{
musictag->SetURL(channel->Path());
musictag->SetTitle(m_strLabel2);
musictag->SetArtist(channel->ChannelName());
musictag->SetAlbumArtist(channel->ChannelName());
if (epgNow)
musictag->SetGenre(epgNow->Genre());
musictag->SetDuration(epgNow ? epgNow->GetDuration() : 3600);
musictag->SetLoaded(true);
musictag->SetComment("");
musictag->SetLyrics("");
}
}
if (!channel->IconPath().empty())
SetIconImage(channel->IconPath());
SetProperty("channelid", channel->ChannelID());
SetProperty("path", channel->Path());
SetArt("thumb", channel->IconPath());
FillInMimeType(false);
}
CFileItem::CFileItem(const CPVRRecordingPtr& record)
{
assert(record.get());
Initialize();
m_bIsFolder = false;
m_pvrRecordingInfoTag = record;
m_strPath = record->m_strFileNameAndPath;
SetLabel(record->m_strTitle);
m_strLabel2 = record->m_strPlot;
FillInMimeType(false);
}
CFileItem::CFileItem(const CPVRTimerInfoTagPtr& timer)
{
assert(timer.get());
Initialize();
m_bIsFolder = timer->IsTimerRule();
m_pvrTimerInfoTag = timer;
m_strPath = timer->Path();
SetLabel(timer->Title());
m_strLabel2 = timer->Summary();
m_dateTime = timer->StartAsLocalTime();
if (!timer->ChannelIcon().empty())
SetIconImage(timer->ChannelIcon());
FillInMimeType(false);
}
CFileItem::CFileItem(const CArtist& artist)
{
Initialize();
SetLabel(artist.strArtist);
m_strPath = artist.strArtist;
m_bIsFolder = true;
URIUtils::AddSlashAtEnd(m_strPath);
GetMusicInfoTag()->SetArtist(artist);
FillInMimeType(false);
}
CFileItem::CFileItem(const CGenre& genre)
{
Initialize();
SetLabel(genre.strGenre);
m_strPath = genre.strGenre;
m_bIsFolder = true;
URIUtils::AddSlashAtEnd(m_strPath);
GetMusicInfoTag()->SetGenre(genre.strGenre);
FillInMimeType(false);
}
CFileItem::CFileItem(const CFileItem& item)
: m_musicInfoTag(NULL),
m_videoInfoTag(NULL),
m_pictureInfoTag(NULL),
m_gameInfoTag(NULL)
{
*this = item;
}
CFileItem::CFileItem(const CGUIListItem& item)
{
Initialize();
// not particularly pretty, but it gets around the issue of Initialize() defaulting
// parameters in the CGUIListItem base class.
*((CGUIListItem *)this) = item;
FillInMimeType(false);
}
CFileItem::CFileItem(void)
{
Initialize();
}
CFileItem::CFileItem(const std::string& strLabel)
{
Initialize();
SetLabel(strLabel);
}
CFileItem::CFileItem(const char* strLabel)
{
Initialize();
SetLabel(std::string(strLabel));
}
CFileItem::CFileItem(const CURL& path, bool bIsFolder)
{
Initialize();
m_strPath = path.Get();
m_bIsFolder = bIsFolder;
if (m_bIsFolder && !m_strPath.empty() && !IsFileFolder())
URIUtils::AddSlashAtEnd(m_strPath);
FillInMimeType(false);
}
CFileItem::CFileItem(const std::string& strPath, bool bIsFolder)
{
Initialize();
m_strPath = strPath;
m_bIsFolder = bIsFolder;
if (m_bIsFolder && !m_strPath.empty() && !IsFileFolder())
URIUtils::AddSlashAtEnd(m_strPath);
FillInMimeType(false);
}
CFileItem::CFileItem(const CMediaSource& share)
{
Initialize();
m_bIsFolder = true;
m_bIsShareOrDrive = true;
m_strPath = share.strPath;
if (!IsRSS()) // no slash at end for rss feeds
URIUtils::AddSlashAtEnd(m_strPath);
std::string label = share.strName;
if (!share.strStatus.empty())
label = StringUtils::Format("%s (%s)", share.strName.c_str(), share.strStatus.c_str());
SetLabel(label);
m_iLockMode = share.m_iLockMode;
m_strLockCode = share.m_strLockCode;
m_iHasLock = share.m_iHasLock;
m_iBadPwdCount = share.m_iBadPwdCount;
m_iDriveType = share.m_iDriveType;
SetArt("thumb", share.m_strThumbnailImage);
SetLabelPreformatted(true);
if (IsDVD())
GetVideoInfoTag()->m_strFileNameAndPath = share.strDiskUniqueId; // share.strDiskUniqueId contains disc unique id
FillInMimeType(false);
}
CFileItem::CFileItem(std::shared_ptr<const ADDON::IAddon> addonInfo) : m_addonInfo(std::move(addonInfo))
{
Initialize();
}
CFileItem::CFileItem(const EventPtr& eventLogEntry)
{
Initialize();
m_eventLogEntry = eventLogEntry;
SetLabel(eventLogEntry->GetLabel());
m_dateTime = eventLogEntry->GetDateTime();
if (!eventLogEntry->GetIcon().empty())
SetIconImage(eventLogEntry->GetIcon());
}
CFileItem::~CFileItem(void)
{
delete m_musicInfoTag;
delete m_videoInfoTag;
delete m_pictureInfoTag;
delete m_gameInfoTag;
m_musicInfoTag = NULL;
m_videoInfoTag = NULL;
m_pictureInfoTag = NULL;
m_gameInfoTag = NULL;
}
const CFileItem& CFileItem::operator=(const CFileItem& item)
{
if (this == &item)
return *this;
CGUIListItem::operator=(item);
m_bLabelPreformatted=item.m_bLabelPreformatted;
FreeMemory();
m_strPath = item.GetPath();
m_bIsParentFolder = item.m_bIsParentFolder;
m_iDriveType = item.m_iDriveType;
m_bIsShareOrDrive = item.m_bIsShareOrDrive;
m_dateTime = item.m_dateTime;
m_dwSize = item.m_dwSize;
if (item.m_musicInfoTag)
{
if (m_musicInfoTag)
*m_musicInfoTag = *item.m_musicInfoTag;
else
m_musicInfoTag = new MUSIC_INFO::CMusicInfoTag(*item.m_musicInfoTag);
}
else
{
delete m_musicInfoTag;
m_musicInfoTag = NULL;
}
if (item.m_videoInfoTag)
{
if (m_videoInfoTag)
*m_videoInfoTag = *item.m_videoInfoTag;
else
m_videoInfoTag = new CVideoInfoTag(*item.m_videoInfoTag);
}
else
{
delete m_videoInfoTag;
m_videoInfoTag = NULL;
}
if (item.m_pictureInfoTag)
{
if (m_pictureInfoTag)
*m_pictureInfoTag = *item.m_pictureInfoTag;
else
m_pictureInfoTag = new CPictureInfoTag(*item.m_pictureInfoTag);
}
else
{
delete m_pictureInfoTag;
m_pictureInfoTag = NULL;
}
if (item.m_gameInfoTag)
{
if (m_gameInfoTag)
*m_gameInfoTag = *item.m_gameInfoTag;
else
m_gameInfoTag = new CGameInfoTag(*item.m_gameInfoTag);
}
else
{
delete m_gameInfoTag;
m_gameInfoTag = NULL;
}
m_epgInfoTag = item.m_epgInfoTag;
m_pvrChannelInfoTag = item.m_pvrChannelInfoTag;
m_pvrRecordingInfoTag = item.m_pvrRecordingInfoTag;
m_pvrTimerInfoTag = item.m_pvrTimerInfoTag;
m_pvrRadioRDSInfoTag = item.m_pvrRadioRDSInfoTag;
m_addonInfo = item.m_addonInfo;
m_eventLogEntry = item.m_eventLogEntry;
m_lStartOffset = item.m_lStartOffset;
m_lStartPartNumber = item.m_lStartPartNumber;
m_lEndOffset = item.m_lEndOffset;
m_strDVDLabel = item.m_strDVDLabel;
m_strTitle = item.m_strTitle;
m_iprogramCount = item.m_iprogramCount;
m_idepth = item.m_idepth;
m_iLockMode = item.m_iLockMode;
m_strLockCode = item.m_strLockCode;
m_iHasLock = item.m_iHasLock;
m_iBadPwdCount = item.m_iBadPwdCount;
m_bCanQueue=item.m_bCanQueue;
m_mimetype = item.m_mimetype;
m_extrainfo = item.m_extrainfo;
m_specialSort = item.m_specialSort;
m_bIsAlbum = item.m_bIsAlbum;
m_doContentLookup = item.m_doContentLookup;
return *this;
}
void CFileItem::Initialize()
{
m_musicInfoTag = NULL;
m_videoInfoTag = NULL;
m_pictureInfoTag = NULL;
m_gameInfoTag = NULL;
m_bLabelPreformatted = false;
m_bIsAlbum = false;
m_dwSize = 0;
m_bIsParentFolder = false;
m_bIsShareOrDrive = false;
m_iDriveType = CMediaSource::SOURCE_TYPE_UNKNOWN;
m_lStartOffset = 0;
m_lStartPartNumber = 1;
m_lEndOffset = 0;
m_iprogramCount = 0;
m_idepth = 1;
m_iLockMode = LOCK_MODE_EVERYONE;
m_iBadPwdCount = 0;
m_iHasLock = 0;
m_bCanQueue = true;
m_specialSort = SortSpecialNone;
m_doContentLookup = true;
}
void CFileItem::Reset()
{
// CGUIListItem members...
m_strLabel2.clear();
SetLabel("");
FreeIcons();
m_overlayIcon = ICON_OVERLAY_NONE;
m_bSelected = false;
m_bIsFolder = false;
m_strDVDLabel.clear();
m_strTitle.clear();
m_strPath.clear();
m_dateTime.Reset();
m_strLockCode.clear();
m_mimetype.clear();
delete m_musicInfoTag;
m_musicInfoTag=NULL;
delete m_videoInfoTag;
m_videoInfoTag=NULL;
m_epgInfoTag.reset();
m_pvrChannelInfoTag.reset();
m_pvrRecordingInfoTag.reset();
m_pvrTimerInfoTag.reset();
m_pvrRadioRDSInfoTag.reset();
delete m_pictureInfoTag;
m_pictureInfoTag=NULL;
delete m_gameInfoTag;
m_gameInfoTag = NULL;
m_extrainfo.clear();
ClearProperties();
m_eventLogEntry.reset();
Initialize();
SetInvalid();
}
void CFileItem::Archive(CArchive& ar)
{
CGUIListItem::Archive(ar);
if (ar.IsStoring())
{
ar << m_bIsParentFolder;
ar << m_bLabelPreformatted;
ar << m_strPath;
ar << m_bIsShareOrDrive;
ar << m_iDriveType;
ar << m_dateTime;
ar << m_dwSize;
ar << m_strDVDLabel;
ar << m_strTitle;
ar << m_iprogramCount;
ar << m_idepth;
ar << m_lStartOffset;
ar << m_lStartPartNumber;
ar << m_lEndOffset;
ar << m_iLockMode;
ar << m_strLockCode;
ar << m_iBadPwdCount;
ar << m_bCanQueue;
ar << m_mimetype;
ar << m_extrainfo;
ar << m_specialSort;
ar << m_doContentLookup;
if (m_musicInfoTag)
{
ar << 1;
ar << *m_musicInfoTag;
}
else
ar << 0;
if (m_videoInfoTag)
{
ar << 1;
ar << *m_videoInfoTag;
}
else
ar << 0;
if (m_pvrRadioRDSInfoTag)
{
ar << 1;
ar << *m_pvrRadioRDSInfoTag;
}
else
ar << 0;
if (m_pictureInfoTag)
{
ar << 1;
ar << *m_pictureInfoTag;
}
else
ar << 0;
if (m_gameInfoTag)
{
ar << 1;
ar << *m_gameInfoTag;
}
else
ar << 0;
}
else
{
ar >> m_bIsParentFolder;
ar >> m_bLabelPreformatted;
ar >> m_strPath;
ar >> m_bIsShareOrDrive;
ar >> m_iDriveType;
ar >> m_dateTime;
ar >> m_dwSize;
ar >> m_strDVDLabel;
ar >> m_strTitle;
ar >> m_iprogramCount;
ar >> m_idepth;
ar >> m_lStartOffset;
ar >> m_lStartPartNumber;
ar >> m_lEndOffset;
int temp;
ar >> temp;
m_iLockMode = (LockType)temp;
ar >> m_strLockCode;
ar >> m_iBadPwdCount;
ar >> m_bCanQueue;
ar >> m_mimetype;
ar >> m_extrainfo;
ar >> temp;
m_specialSort = (SortSpecial)temp;
ar >> m_doContentLookup;
int iType;
ar >> iType;
if (iType == 1)
ar >> *GetMusicInfoTag();
ar >> iType;
if (iType == 1)
ar >> *GetVideoInfoTag();
ar >> iType;
if (iType == 1)
ar >> *m_pvrRadioRDSInfoTag;
ar >> iType;
if (iType == 1)
ar >> *GetPictureInfoTag();
ar >> iType;
if (iType == 1)
ar >> *GetGameInfoTag();
SetInvalid();
}
}
void CFileItem::Serialize(CVariant& value) const
{
//CGUIListItem::Serialize(value["CGUIListItem"]);
value["strPath"] = m_strPath;
value["dateTime"] = (m_dateTime.IsValid()) ? m_dateTime.GetAsRFC1123DateTime() : "";
value["lastmodified"] = m_dateTime.IsValid() ? m_dateTime.GetAsDBDateTime() : "";
value["size"] = m_dwSize;
value["DVDLabel"] = m_strDVDLabel;
value["title"] = m_strTitle;
value["mimetype"] = m_mimetype;
value["extrainfo"] = m_extrainfo;
if (m_musicInfoTag)
(*m_musicInfoTag).Serialize(value["musicInfoTag"]);
if (m_videoInfoTag)
(*m_videoInfoTag).Serialize(value["videoInfoTag"]);
if (m_pvrRadioRDSInfoTag)
m_pvrRadioRDSInfoTag->Serialize(value["rdsInfoTag"]);
if (m_pictureInfoTag)
(*m_pictureInfoTag).Serialize(value["pictureInfoTag"]);
if (m_gameInfoTag)
(*m_gameInfoTag).Serialize(value["gameInfoTag"]);
}
void CFileItem::ToSortable(SortItem &sortable, Field field) const
{
switch (field)
{
case FieldPath:
sortable[FieldPath] = m_strPath;
break;
case FieldDate:
sortable[FieldDate] = (m_dateTime.IsValid()) ? m_dateTime.GetAsDBDateTime() : "";
break;
case FieldSize:
sortable[FieldSize] = m_dwSize;
break;
case FieldDriveType:
sortable[FieldDriveType] = m_iDriveType;
break;
case FieldStartOffset:
sortable[FieldStartOffset] = m_lStartOffset;
break;
case FieldEndOffset:
sortable[FieldEndOffset] = m_lEndOffset;
break;
case FieldProgramCount:
sortable[FieldProgramCount] = m_iprogramCount;
break;
case FieldBitrate:
sortable[FieldBitrate] = m_dwSize;
break;
case FieldTitle:
sortable[FieldTitle] = m_strTitle;
break;
// If there's ever a need to convert more properties from CGUIListItem it might be
// worth to make CGUIListItem implement ISortable as well and call it from here
default:
break;
}
if (HasMusicInfoTag())
GetMusicInfoTag()->ToSortable(sortable, field);
if (HasVideoInfoTag())
GetVideoInfoTag()->ToSortable(sortable, field);
if (HasPictureInfoTag())
GetPictureInfoTag()->ToSortable(sortable, field);
if (HasPVRChannelInfoTag())
GetPVRChannelInfoTag()->ToSortable(sortable, field);
if (HasAddonInfo())
{
switch (field)
{
case FieldInstallDate:
sortable[FieldInstallDate] = GetAddonInfo()->InstallDate().GetAsDBDateTime();
break;
case FieldLastUpdated:
sortable[FieldLastUpdated] = GetAddonInfo()->LastUpdated().GetAsDBDateTime();
break;
case FieldLastUsed:
sortable[FieldLastUsed] = GetAddonInfo()->LastUsed().GetAsDBDateTime();
break;
default:
break;
}
}
if (HasGameInfoTag())
GetGameInfoTag()->ToSortable(sortable, field);
if (m_eventLogEntry)
m_eventLogEntry->ToSortable(sortable, field);
}
void CFileItem::ToSortable(SortItem &sortable, const Fields &fields) const
{
Fields::const_iterator it;
for (it = fields.begin(); it != fields.end(); it++)
ToSortable(sortable, *it);
/* FieldLabel is used as a fallback by all sorters and therefore has to be present as well */
sortable[FieldLabel] = GetLabel();
/* FieldSortSpecial and FieldFolder are required in conjunction with all other sorters as well */
sortable[FieldSortSpecial] = m_specialSort;
sortable[FieldFolder] = m_bIsFolder;
}
bool CFileItem::Exists(bool bUseCache /* = true */) const
{
if (m_strPath.empty()
|| IsPath("add")
|| IsInternetStream()
|| IsParentFolder()
|| IsVirtualDirectoryRoot()
|| IsPlugin()
|| IsPVR())
return true;
if (IsVideoDb() && HasVideoInfoTag())
{
CFileItem dbItem(m_bIsFolder ? GetVideoInfoTag()->m_strPath : GetVideoInfoTag()->m_strFileNameAndPath, m_bIsFolder);
return dbItem.Exists();
}
std::string strPath = m_strPath;
if (URIUtils::IsMultiPath(strPath))
strPath = CMultiPathDirectory::GetFirstPath(strPath);
if (URIUtils::IsStack(strPath))
strPath = CStackDirectory::GetFirstStackedFile(strPath);
if (m_bIsFolder)
return CDirectory::Exists(strPath, bUseCache);
else
return CFile::Exists(strPath, bUseCache);
return false;
}
bool CFileItem::IsVideo() const
{
/* check preset mime type */
if(StringUtils::StartsWithNoCase(m_mimetype, "video/"))
return true;
if (HasVideoInfoTag())
return true;
if (HasGameInfoTag())
return false;
if (HasMusicInfoTag())
return false;
if (HasPictureInfoTag())
return false;
// only tv recordings are videos...
if (IsPVRRecording())
return !GetPVRRecordingInfoTag()->IsRadio();
// ... all other PVR items are not.
if (IsPVR())
return false;
if (URIUtils::IsDVD(m_strPath))
return true;
std::string extension;
if(StringUtils::StartsWithNoCase(m_mimetype, "application/"))
{ /* check for some standard types */
extension = m_mimetype.substr(12);
if( StringUtils::EqualsNoCase(extension, "ogg")
|| StringUtils::EqualsNoCase(extension, "mp4")
|| StringUtils::EqualsNoCase(extension, "mxf") )
return true;
}
//! @todo If the file is a zip file, ask the game clients if any support this
// file before assuming it is video.
return URIUtils::HasExtension(m_strPath, g_advancedSettings.m_videoExtensions);
}
bool CFileItem::IsEPG() const
{
return HasEPGInfoTag();
}
bool CFileItem::IsPVRChannel() const
{
return HasPVRChannelInfoTag();
}
bool CFileItem::IsPVRRecording() const
{
return HasPVRRecordingInfoTag();
}
bool CFileItem::IsUsablePVRRecording() const
{
return (m_pvrRecordingInfoTag && !m_pvrRecordingInfoTag->IsDeleted());
}
bool CFileItem::IsDeletedPVRRecording() const
{
return (m_pvrRecordingInfoTag && m_pvrRecordingInfoTag->IsDeleted());
}
bool CFileItem::IsPVRTimer() const
{
return HasPVRTimerInfoTag();
}
bool CFileItem::IsPVRRadioRDS() const
{
return HasPVRRadioRDSInfoTag();
}
bool CFileItem::IsDiscStub() const
{
if (IsVideoDb() && HasVideoInfoTag())
{
CFileItem dbItem(m_bIsFolder ? GetVideoInfoTag()->m_strPath : GetVideoInfoTag()->m_strFileNameAndPath, m_bIsFolder);
return dbItem.IsDiscStub();
}
return URIUtils::HasExtension(m_strPath, g_advancedSettings.m_discStubExtensions);
}
bool CFileItem::IsAudio() const
{
/* check preset mime type */
if(StringUtils::StartsWithNoCase(m_mimetype, "audio/"))
return true;
if (HasMusicInfoTag())
return true;
if (HasVideoInfoTag())
return false;
if (HasPictureInfoTag())
return false;
if (HasGameInfoTag())
return false;
if (IsCDDA())
return true;
if(StringUtils::StartsWithNoCase(m_mimetype, "application/"))
{ /* check for some standard types */
std::string extension = m_mimetype.substr(12);
if( StringUtils::EqualsNoCase(extension, "ogg")
|| StringUtils::EqualsNoCase(extension, "mp4")
|| StringUtils::EqualsNoCase(extension, "mxf") )
return true;
}
//! @todo If the file is a zip file, ask the game clients if any support this
// file before assuming it is audio
return URIUtils::HasExtension(m_strPath, g_advancedSettings.GetMusicExtensions());
}
bool CFileItem::IsDeleted() const
{
if (HasPVRRecordingInfoTag())
return GetPVRRecordingInfoTag()->IsDeleted();
return false;
}
bool CFileItem::IsAudioBook() const
{
return IsType(".m4b") || IsType(".mka");
}
bool CFileItem::IsGame() const
{
if (HasGameInfoTag())
return true;
if (HasVideoInfoTag())
return false;
if (HasMusicInfoTag())
return false;
if (HasPictureInfoTag())
return false;
if (IsPVR())
return false;
if (HasAddonInfo())
return CGameUtils::IsStandaloneGame(std::const_pointer_cast<ADDON::IAddon>(GetAddonInfo()));
return CGameUtils::HasGameExtension(m_strPath);
}
bool CFileItem::IsPicture() const
{
if(StringUtils::StartsWithNoCase(m_mimetype, "image/"))
return true;
if (HasPictureInfoTag())
return true;
if (HasGameInfoTag())
return false;
if (HasMusicInfoTag())
return false;
if (HasVideoInfoTag())
return false;
return CUtil::IsPicture(m_strPath);
}
bool CFileItem::IsLyrics() const
{
return URIUtils::HasExtension(m_strPath, ".cdg|.lrc");
}
bool CFileItem::IsSubtitle() const
{
return URIUtils::HasExtension(m_strPath, g_advancedSettings.m_subtitlesExtensions);
}
bool CFileItem::IsCUESheet() const
{
return URIUtils::HasExtension(m_strPath, ".cue");
}
bool CFileItem::IsInternetStream(const bool bStrictCheck /* = false */) const
{
if (HasProperty("IsHTTPDirectory"))
return false;
return URIUtils::IsInternetStream(m_strPath, bStrictCheck);
}
bool CFileItem::IsFileFolder(EFileFolderType types) const
{
EFileFolderType always_type = EFILEFOLDER_TYPE_ALWAYS;
/* internet streams are not directly expanded */
if(IsInternetStream())
always_type = EFILEFOLDER_TYPE_ONCLICK;
if(types & always_type)
{
if(IsSmartPlayList()
|| (IsPlayList() && g_advancedSettings.m_playlistAsFolders)
|| IsAPK()
|| IsZIP()
|| IsRAR()
|| IsRSS()
|| IsAudioBook()
|| IsType(".ogg|.oga|.nsf|.sid|.sap|.xbt|.xsp")
#if defined(TARGET_ANDROID)
|| IsType(".apk")
#endif
)
return true;
}
if(types & EFILEFOLDER_TYPE_ONBROWSE)
{
if((IsPlayList() && !g_advancedSettings.m_playlistAsFolders)
|| IsDiscImage())
return true;
}
return false;
}
bool CFileItem::IsSmartPlayList() const
{
if (HasProperty("library.smartplaylist") && GetProperty("library.smartplaylist").asBoolean())
return true;
return URIUtils::HasExtension(m_strPath, ".xsp");
}
bool CFileItem::IsLibraryFolder() const
{
if (HasProperty("library.filter") && GetProperty("library.filter").asBoolean())
return true;
return URIUtils::IsLibraryFolder(m_strPath);
}
bool CFileItem::IsPlayList() const
{
return CPlayListFactory::IsPlaylist(*this);
}
bool CFileItem::IsPythonScript() const
{
return URIUtils::HasExtension(m_strPath, ".py");
}
bool CFileItem::IsType(const char *ext) const
{
return URIUtils::HasExtension(m_strPath, ext);
}
bool CFileItem::IsNFO() const
{
return URIUtils::HasExtension(m_strPath, ".nfo");
}
bool CFileItem::IsDiscImage() const
{
return URIUtils::HasExtension(m_strPath, ".img|.iso|.nrg");
}
bool CFileItem::IsOpticalMediaFile() const
{
if (IsDVDFile(false, true))
return true;
return IsBDFile();
}
bool CFileItem::IsDVDFile(bool bVobs /*= true*/, bool bIfos /*= true*/) const
{
std::string strFileName = URIUtils::GetFileName(m_strPath);
if (bIfos)
{
if (StringUtils::EqualsNoCase(strFileName, "video_ts.ifo"))
return true;
if (StringUtils::StartsWithNoCase(strFileName, "vts_") && StringUtils::EndsWithNoCase(strFileName, "_0.ifo") && strFileName.length() == 12)
return true;
}
if (bVobs)
{
if (StringUtils::EqualsNoCase(strFileName, "video_ts.vob"))
return true;
if (StringUtils::StartsWithNoCase(strFileName, "vts_") && StringUtils::EndsWithNoCase(strFileName, ".vob"))
return true;
}
return false;
}
bool CFileItem::IsBDFile() const
{
std::string strFileName = URIUtils::GetFileName(m_strPath);
return (StringUtils::EqualsNoCase(strFileName, "index.bdmv") || StringUtils::EqualsNoCase(strFileName, "MovieObject.bdmv"));
}
bool CFileItem::IsRAR() const
{
return URIUtils::IsRAR(m_strPath);
}
bool CFileItem::IsAPK() const
{
return URIUtils::IsAPK(m_strPath);
}
bool CFileItem::IsZIP() const
{
return URIUtils::IsZIP(m_strPath);
}
bool CFileItem::IsCBZ() const
{
return URIUtils::HasExtension(m_strPath, ".cbz");
}
bool CFileItem::IsCBR() const
{
return URIUtils::HasExtension(m_strPath, ".cbr");
}
bool CFileItem::IsRSS() const
{
return StringUtils::StartsWithNoCase(m_strPath, "rss://") || URIUtils::HasExtension(m_strPath, ".rss")
|| m_mimetype == "application/rss+xml";
}
bool CFileItem::IsAndroidApp() const
{
return URIUtils::IsAndroidApp(m_strPath);
}
bool CFileItem::IsStack() const
{
return URIUtils::IsStack(m_strPath);
}
bool CFileItem::IsPlugin() const
{
return URIUtils::IsPlugin(m_strPath);
}
bool CFileItem::IsScript() const
{
return URIUtils::IsScript(m_strPath);
}
bool CFileItem::IsAddonsPath() const
{
return URIUtils::IsAddonsPath(m_strPath);
}
bool CFileItem::IsSourcesPath() const
{
return URIUtils::IsSourcesPath(m_strPath);
}
bool CFileItem::IsMultiPath() const
{
return URIUtils::IsMultiPath(m_strPath);
}
bool CFileItem::IsCDDA() const
{
return URIUtils::IsCDDA(m_strPath);
}
bool CFileItem::IsDVD() const
{
return URIUtils::IsDVD(m_strPath) || m_iDriveType == CMediaSource::SOURCE_TYPE_DVD;
}
bool CFileItem::IsOnDVD() const
{
return URIUtils::IsOnDVD(m_strPath) || m_iDriveType == CMediaSource::SOURCE_TYPE_DVD;
}
bool CFileItem::IsNfs() const
{
return URIUtils::IsNfs(m_strPath);
}
bool CFileItem::IsOnLAN() const
{
return URIUtils::IsOnLAN(m_strPath);
}
bool CFileItem::IsISO9660() const
{
return URIUtils::IsISO9660(m_strPath);
}
bool CFileItem::IsRemote() const
{
return URIUtils::IsRemote(m_strPath);
}
bool CFileItem::IsSmb() const
{
return URIUtils::IsSmb(m_strPath);
}
bool CFileItem::IsURL() const
{
return URIUtils::IsURL(m_strPath);
}
bool CFileItem::IsPVR() const
{
return CUtil::IsPVR(m_strPath);
}
bool CFileItem::IsLiveTV() const
{
return URIUtils::IsLiveTV(m_strPath);
}
bool CFileItem::IsHD() const
{
return URIUtils::IsHD(m_strPath);
}
bool CFileItem::IsMusicDb() const
{
return URIUtils::IsMusicDb(m_strPath);
}
bool CFileItem::IsVideoDb() const
{
return URIUtils::IsVideoDb(m_strPath);
}
bool CFileItem::IsVirtualDirectoryRoot() const
{
return (m_bIsFolder && m_strPath.empty());
}
bool CFileItem::IsRemovable() const
{
return IsOnDVD() || IsCDDA() || m_iDriveType == CMediaSource::SOURCE_TYPE_REMOVABLE;
}
bool CFileItem::IsReadOnly() const
{
if (IsParentFolder())
return true;
if (m_bIsShareOrDrive)
return true;
return !CUtil::SupportsWriteFileOperations(m_strPath);
}
void CFileItem::FillInDefaultIcon()
{
if (URIUtils::IsPVRGuideItem(m_strPath))
{
// epg items never have a default icon. no need to execute this expensive method.
// when filling epg grid window, easily tens of thousands of epg items are processed.
return;
}
//CLog::Log(LOGINFO, "FillInDefaultIcon(%s)", pItem->GetLabel().c_str());
// find the default icon for a file or folder item
// for files this can be the (depending on the file type)
// default picture for photo's
// default picture for songs
// default picture for videos
// default picture for shortcuts
// default picture for playlists
//
// for folders
// for .. folders the default picture for parent folder
// for other folders the defaultFolder.png
if (GetIconImage().empty())
{
if (!m_bIsFolder)
{
/* To reduce the average runtime of this code, this list should
* be ordered with most frequently seen types first. Also bear
* in mind the complexity of the code behind the check in the
* case of IsWhatever() returns false.
*/
if (IsPVRChannel())
{
if (GetPVRChannelInfoTag()->IsRadio())
SetIconImage("DefaultAudio.png");
else
SetIconImage("DefaultVideo.png");
}
else if ( IsLiveTV() )
{
// Live TV Channel
SetIconImage("DefaultVideo.png");
}
else if ( URIUtils::IsArchive(m_strPath) )
{ // archive
SetIconImage("DefaultFile.png");
}
else if ( IsUsablePVRRecording() )
{
// PVR recording
SetIconImage("DefaultVideo.png");
}
else if ( IsDeletedPVRRecording() )
{
// PVR deleted recording
SetIconImage("DefaultVideoDeleted.png");
}
else if ( IsAudio() )
{
// audio
SetIconImage("DefaultAudio.png");
}
else if ( IsVideo() )
{
// video
SetIconImage("DefaultVideo.png");
}
else if (IsPVRTimer())
{
SetIconImage("DefaultVideo.png");
}
else if ( IsPicture() )
{
// picture
SetIconImage("DefaultPicture.png");
}
else if ( IsPlayList() || IsSmartPlayList())
{
SetIconImage("DefaultPlaylist.png");
}
else if ( IsPythonScript() )
{
SetIconImage("DefaultScript.png");
}
else
{
// default icon for unknown file type
SetIconImage("DefaultFile.png");
}
}
else
{
if ( IsPlayList() || IsSmartPlayList())
{
SetIconImage("DefaultPlaylist.png");
}
else if (IsParentFolder())
{
SetIconImage("DefaultFolderBack.png");
}
else
{
SetIconImage("DefaultFolder.png");
}
}
}
// Set the icon overlays (if applicable)
if (!HasOverlay())
{
if (URIUtils::IsInRAR(m_strPath))
SetOverlayImage(CGUIListItem::ICON_OVERLAY_RAR);
else if (URIUtils::IsInZIP(m_strPath))
SetOverlayImage(CGUIListItem::ICON_OVERLAY_ZIP);
}
}
void CFileItem::RemoveExtension()
{
if (m_bIsFolder)
return;
std::string strLabel = GetLabel();
URIUtils::RemoveExtension(strLabel);
SetLabel(strLabel);
}
void CFileItem::CleanString()
{
if (IsLiveTV())
return;
std::string strLabel = GetLabel();
std::string strTitle, strTitleAndYear, strYear;
CUtil::CleanString(strLabel, strTitle, strTitleAndYear, strYear, true);
SetLabel(strTitleAndYear);
}
void CFileItem::SetLabel(const std::string &strLabel)
{
if (strLabel == "..")
{
m_bIsParentFolder = true;
m_bIsFolder = true;
m_specialSort = SortSpecialOnTop;
SetLabelPreformatted(true);
}
CGUIListItem::SetLabel(strLabel);
}
void CFileItem::SetFileSizeLabel()
{
if(m_bIsFolder && m_dwSize == 0)
SetLabel2("");
else
SetLabel2(StringUtils::SizeToString(m_dwSize));
}
bool CFileItem::CanQueue() const
{
return m_bCanQueue;
}
void CFileItem::SetCanQueue(bool bYesNo)
{
m_bCanQueue = bYesNo;
}
bool CFileItem::IsParentFolder() const
{
return m_bIsParentFolder;
}
void CFileItem::FillInMimeType(bool lookup /*= true*/)
{
//! @todo adapt this to use CMime::GetMimeType()
if (m_mimetype.empty())
{
if( m_bIsFolder )
m_mimetype = "x-directory/normal";
else if( m_pvrChannelInfoTag )
m_mimetype = m_pvrChannelInfoTag->InputFormat();
else if( StringUtils::StartsWithNoCase(m_strPath, "shout://")
|| StringUtils::StartsWithNoCase(m_strPath, "http://")
|| StringUtils::StartsWithNoCase(m_strPath, "https://"))
{
// If lookup is false, bail out early to leave mime type empty
if (!lookup)
return;
CCurlFile::GetMimeType(GetURL(), m_mimetype);
// try to get mime-type again but with an NSPlayer User-Agent
// in order for server to provide correct mime-type. Allows us
// to properly detect an MMS stream
if (StringUtils::StartsWithNoCase(m_mimetype, "video/x-ms-"))
CCurlFile::GetMimeType(GetURL(), m_mimetype, "NSPlayer/11.00.6001.7000");
// make sure there are no options set in mime-type
// mime-type can look like "video/x-ms-asf ; charset=utf8"
size_t i = m_mimetype.find(';');
if(i != std::string::npos)
m_mimetype.erase(i, m_mimetype.length() - i);
StringUtils::Trim(m_mimetype);
}
else
m_mimetype = CMime::GetMimeType(*this);
// if it's still empty set to an unknown type
if (m_mimetype.empty())
m_mimetype = "application/octet-stream";
}
// change protocol to mms for the following mime-type. Allows us to create proper FileMMS.
if( StringUtils::StartsWithNoCase(m_mimetype, "application/vnd.ms.wms-hdr.asfv1") || StringUtils::StartsWithNoCase(m_mimetype, "application/x-mms-framed") )
StringUtils::Replace(m_strPath, "http:", "mms:");
}
void CFileItem::SetMimeTypeForInternetFile()
{
if (m_doContentLookup && IsInternetStream())
{
SetMimeType("");
FillInMimeType(true);
}
}
bool CFileItem::IsSamePath(const CFileItem *item) const
{
if (!item)
return false;
if (item->GetPath() == m_strPath)
{
if (item->HasProperty("item_start") || HasProperty("item_start"))
return (item->GetProperty("item_start") == GetProperty("item_start"));
return true;
}
if (HasVideoInfoTag() && item->HasVideoInfoTag())
{
if (GetVideoInfoTag()->m_iDbId != -1 && item->GetVideoInfoTag()->m_iDbId != -1)
return ((GetVideoInfoTag()->m_iDbId == item->GetVideoInfoTag()->m_iDbId) &&
(GetVideoInfoTag()->m_type == item->GetVideoInfoTag()->m_type));
}
if (IsMusicDb() && HasMusicInfoTag())
{
CFileItem dbItem(m_musicInfoTag->GetURL(), false);
if (HasProperty("item_start"))
dbItem.SetProperty("item_start", GetProperty("item_start"));
return dbItem.IsSamePath(item);
}
if (IsVideoDb() && HasVideoInfoTag())
{
CFileItem dbItem(GetVideoInfoTag()->m_strFileNameAndPath, false);
if (HasProperty("item_start"))
dbItem.SetProperty("item_start", GetProperty("item_start"));
return dbItem.IsSamePath(item);
}
if (item->IsMusicDb() && item->HasMusicInfoTag())
{
CFileItem dbItem(item->m_musicInfoTag->GetURL(), false);
if (item->HasProperty("item_start"))
dbItem.SetProperty("item_start", item->GetProperty("item_start"));
return IsSamePath(&dbItem);
}
if (item->IsVideoDb() && item->HasVideoInfoTag())
{
CFileItem dbItem(item->GetVideoInfoTag()->m_strFileNameAndPath, false);
if (item->HasProperty("item_start"))
dbItem.SetProperty("item_start", item->GetProperty("item_start"));
return IsSamePath(&dbItem);
}
if (HasProperty("original_listitem_url"))
return (GetProperty("original_listitem_url") == item->GetPath());
return false;
}
bool CFileItem::IsAlbum() const
{
return m_bIsAlbum;
}
void CFileItem::UpdateInfo(const CFileItem &item, bool replaceLabels /*=true*/)
{
if (item.HasVideoInfoTag())
{ // copy info across
//! @todo premiered info is normally stored in m_dateTime by the db
if (item.m_videoInfoTag)
{
if (m_videoInfoTag)
*m_videoInfoTag = *item.m_videoInfoTag;
else
m_videoInfoTag = new CVideoInfoTag(*item.m_videoInfoTag);
}
else
{
if (m_videoInfoTag)
delete m_videoInfoTag;
m_videoInfoTag = new CVideoInfoTag;
}
m_pvrRecordingInfoTag = item.m_pvrRecordingInfoTag;
SetOverlayImage(ICON_OVERLAY_UNWATCHED, GetVideoInfoTag()->GetPlayCount() > 0);
SetInvalid();
}
if (item.HasMusicInfoTag())
{
*GetMusicInfoTag() = *item.GetMusicInfoTag();
SetInvalid();
}
if (item.HasPVRRadioRDSInfoTag())
{
m_pvrRadioRDSInfoTag = item.m_pvrRadioRDSInfoTag;
SetInvalid();
}
if (item.HasPictureInfoTag())
{
*GetPictureInfoTag() = *item.GetPictureInfoTag();
SetInvalid();
}
if (item.HasGameInfoTag())
{
*GetGameInfoTag() = *item.GetGameInfoTag();
SetInvalid();
}
if (replaceLabels && !item.GetLabel().empty())
SetLabel(item.GetLabel());
if (replaceLabels && !item.GetLabel2().empty())
SetLabel2(item.GetLabel2());
if (!item.GetArt("thumb").empty())
SetArt("thumb", item.GetArt("thumb"));
if (!item.GetIconImage().empty())
SetIconImage(item.GetIconImage());
AppendProperties(item);
}
void CFileItem::SetFromVideoInfoTag(const CVideoInfoTag &video)
{
if (!video.m_strTitle.empty())
SetLabel(video.m_strTitle);
if (video.m_strFileNameAndPath.empty())
{
m_strPath = video.m_strPath;
URIUtils::AddSlashAtEnd(m_strPath);
m_bIsFolder = true;
}
else
{
m_strPath = video.m_strFileNameAndPath;
m_bIsFolder = false;
}
if (m_videoInfoTag)
*m_videoInfoTag = video;
else
m_videoInfoTag = new CVideoInfoTag(video);
if (video.m_iSeason == 0)
SetProperty("isspecial", "true");
FillInDefaultIcon();
FillInMimeType(false);
}
void CFileItem::SetFromMusicInfoTag(const MUSIC_INFO::CMusicInfoTag &music)
{
if (!music.GetTitle().empty())
SetLabel(music.GetTitle());
if (!music.GetURL().empty())
m_strPath = music.GetURL();
m_bIsFolder = URIUtils::HasSlashAtEnd(m_strPath);
*GetMusicInfoTag() = music;
FillInDefaultIcon();
FillInMimeType(false);
}
void CFileItem::SetFromAlbum(const CAlbum &album)
{
if (!album.strAlbum.empty())
SetLabel(album.strAlbum);
m_bIsFolder = true;
m_strLabel2 = album.GetAlbumArtistString();
GetMusicInfoTag()->SetAlbum(album);
SetArt(album.art);
m_bIsAlbum = true;
CMusicDatabase::SetPropertiesFromAlbum(*this,album);
FillInMimeType(false);
}
void CFileItem::SetFromSong(const CSong &song)
{
if (!song.strTitle.empty())
SetLabel(song.strTitle);
if (song.idSong > 0)
{
std::string strExt = URIUtils::GetExtension(song.strFileName);
m_strPath = StringUtils::Format("musicdb://songs/%li%s", song.idSong, strExt.c_str());
}
else if (!song.strFileName.empty())
m_strPath = song.strFileName;
GetMusicInfoTag()->SetSong(song);
m_lStartOffset = song.iStartOffset;
m_lStartPartNumber = 1;
SetProperty("item_start", song.iStartOffset);
m_lEndOffset = song.iEndOffset;
if (!song.strThumb.empty())
SetArt("thumb", song.strThumb);
FillInMimeType(false);
}
std::string CFileItem::GetOpticalMediaPath() const
{
std::string path;
path = URIUtils::AddFileToFolder(GetPath(), "VIDEO_TS.IFO");
if (CFile::Exists(path))
return path;
path = URIUtils::AddFileToFolder(GetPath(), "VIDEO_TS", "VIDEO_TS.IFO");
if (CFile::Exists(path))
return path;
#ifdef HAVE_LIBBLURAY
path = URIUtils::AddFileToFolder(GetPath(), "index.bdmv");
if (CFile::Exists(path))
return path;
path = URIUtils::AddFileToFolder(GetPath(), "BDMV", "index.bdmv");
if (CFile::Exists(path))
return path;
#endif
return std::string();
}
/**
* @todo Ideally this (and SetPath) would not be available outside of construction
* for CFileItem objects, or at least restricted to essentially be equivalent
* to construction. This would require re-formulating a bunch of CFileItem
* construction, and also allowing CFileItemList to have it's own (public)
* SetURL() function, so for now we give direct access.
*/
void CFileItem::SetURL(const CURL& url)
{
m_strPath = url.Get();
}
const CURL CFileItem::GetURL() const
{
CURL url(m_strPath);
return url;
}
bool CFileItem::IsURL(const CURL& url) const
{
return IsPath(url.Get());
}
bool CFileItem::IsPath(const std::string& path, bool ignoreURLOptions /* = false */) const
{
return URIUtils::PathEquals(m_strPath, path, false, ignoreURLOptions);
}
void CFileItem::SetCueDocument(const CCueDocumentPtr& cuePtr)
{
m_cueDocument = cuePtr;
}
void CFileItem::LoadEmbeddedCue()
{
CMusicInfoTag& tag = *GetMusicInfoTag();
if (!tag.Loaded())
return;
const std::string embeddedCue = tag.GetCueSheet();
if (!embeddedCue.empty())
{
CCueDocumentPtr cuesheet(new CCueDocument);
if (cuesheet->ParseTag(embeddedCue))
{
std::vector<std::string> MediaFileVec;
cuesheet->GetMediaFiles(MediaFileVec);
for (std::vector<std::string>::iterator itMedia = MediaFileVec.begin(); itMedia != MediaFileVec.end(); itMedia++)
cuesheet->UpdateMediaFile(*itMedia, GetPath());
SetCueDocument(cuesheet);
}
}
}
bool CFileItem::HasCueDocument() const
{
return (m_cueDocument.get() != nullptr);
}
bool CFileItem::LoadTracksFromCueDocument(CFileItemList& scannedItems)
{
if (!m_cueDocument)
return false;
CMusicInfoTag& tag = *GetMusicInfoTag();
VECSONGS tracks;
m_cueDocument->GetSongs(tracks);
bool oneFilePerTrack = m_cueDocument->IsOneFilePerTrack();
m_cueDocument.reset();
int tracksFound = 0;
for (VECSONGS::iterator it = tracks.begin(); it != tracks.end(); ++it)
{
CSong& song = *it;
if (song.strFileName == GetPath())
{
if (tag.Loaded())
{
if (song.strAlbum.empty() && !tag.GetAlbum().empty())
song.strAlbum = tag.GetAlbum();
//Pass album artist to final MusicInfoTag object via setting song album artist vector.
if (song.GetAlbumArtist().empty() && !tag.GetAlbumArtist().empty())
song.SetAlbumArtist(tag.GetAlbumArtist());
if (song.genre.empty() && !tag.GetGenre().empty())
song.genre = tag.GetGenre();
//Pass artist to final MusicInfoTag object via setting song artist description string only.
//Artist credits not used during loading from cue sheet.
if (song.strArtistDesc.empty() && !tag.GetArtistString().empty())
song.strArtistDesc = tag.GetArtistString();
if (tag.GetDiscNumber())
song.iTrack |= (tag.GetDiscNumber() << 16); // see CMusicInfoTag::GetDiscNumber()
if (!tag.GetCueSheet().empty())
song.strCueSheet = tag.GetCueSheet();
SYSTEMTIME dateTime;
tag.GetReleaseDate(dateTime);
if (dateTime.wYear)
song.iYear = dateTime.wYear;
if (song.embeddedArt.empty() && !tag.GetCoverArtInfo().empty())
song.embeddedArt = tag.GetCoverArtInfo();
}
if (!song.iDuration && tag.GetDuration() > 0)
{ // must be the last song
song.iDuration = (tag.GetDuration() * 75 - song.iStartOffset + 37) / 75;
}
if ( tag.Loaded() && oneFilePerTrack && ! ( tag.GetAlbum().empty() || tag.GetArtist().empty() || tag.GetTitle().empty() ) )
{
// If there are multiple files in a cue file, the tags from the files should be prefered if they exist.
scannedItems.Add(CFileItemPtr(new CFileItem(song, tag)));
}
else
{
scannedItems.Add(CFileItemPtr(new CFileItem(song)));
}
++tracksFound;
}
}
return tracksFound != 0;
}
/////////////////////////////////////////////////////////////////////////////////
/////
///// CFileItemList
/////
//////////////////////////////////////////////////////////////////////////////////
CFileItemList::CFileItemList()
: CFileItem("", true),
m_ignoreURLOptions(false),
m_fastLookup(false),
m_sortIgnoreFolders(false),
m_cacheToDisc(CACHE_IF_SLOW),
m_replaceListing(false)
{
}
CFileItemList::CFileItemList(const std::string& strPath)
: CFileItem(strPath, true),
m_ignoreURLOptions(false),
m_fastLookup(false),
m_sortIgnoreFolders(false),
m_cacheToDisc(CACHE_IF_SLOW),
m_replaceListing(false)
{
}
CFileItemList::~CFileItemList()
{
Clear();
}
CFileItemPtr CFileItemList::operator[] (int iItem)
{
return Get(iItem);
}
const CFileItemPtr CFileItemList::operator[] (int iItem) const
{
return Get(iItem);
}
CFileItemPtr CFileItemList::operator[] (const std::string& strPath)
{
return Get(strPath);
}
const CFileItemPtr CFileItemList::operator[] (const std::string& strPath) const
{
return Get(strPath);
}
void CFileItemList::SetIgnoreURLOptions(bool ignoreURLOptions)
{
m_ignoreURLOptions = ignoreURLOptions;
if (m_fastLookup)
{
m_fastLookup = false; // Force SetFastlookup to clear map
SetFastLookup(true); // and regenerate map
}
}
void CFileItemList::SetFastLookup(bool fastLookup)
{
CSingleLock lock(m_lock);
if (fastLookup && !m_fastLookup)
{ // generate the map
m_map.clear();
for (unsigned int i=0; i < m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath(), pItem));
}
}
if (!fastLookup && m_fastLookup)
m_map.clear();
m_fastLookup = fastLookup;
}
bool CFileItemList::Contains(const std::string& fileName) const
{
CSingleLock lock(m_lock);
if (m_fastLookup)
return m_map.find(m_ignoreURLOptions ? CURL(fileName).GetWithoutOptions() : fileName) != m_map.end();
// slow method...
for (unsigned int i = 0; i < m_items.size(); i++)
{
const CFileItemPtr pItem = m_items[i];
if (pItem->IsPath(m_ignoreURLOptions ? CURL(fileName).GetWithoutOptions() : fileName))
return true;
}
return false;
}
void CFileItemList::Clear()
{
CSingleLock lock(m_lock);
ClearItems();
m_sortDescription.sortBy = SortByNone;
m_sortDescription.sortOrder = SortOrderNone;
m_sortDescription.sortAttributes = SortAttributeNone;
m_sortIgnoreFolders = false;
m_cacheToDisc = CACHE_IF_SLOW;
m_sortDetails.clear();
m_replaceListing = false;
m_content.clear();
}
void CFileItemList::ClearItems()
{
CSingleLock lock(m_lock);
// make sure we free the memory of the items (these are GUIControls which may have allocated resources)
FreeMemory();
for (unsigned int i = 0; i < m_items.size(); i++)
{
CFileItemPtr item = m_items[i];
item->FreeMemory();
}
m_items.clear();
m_map.clear();
}
void CFileItemList::Add(CFileItemPtr pItem)
{
CSingleLock lock(m_lock);
if (m_fastLookup)
m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath(), pItem));
m_items.emplace_back(std::move(pItem));
}
void CFileItemList::Add(CFileItem&& item)
{
CSingleLock lock(m_lock);
auto ptr = std::make_shared<CFileItem>(std::move(item));
if (m_fastLookup)
m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(ptr->GetPath()).GetWithoutOptions() : ptr->GetPath(), ptr));
m_items.emplace_back(std::move(ptr));
}
void CFileItemList::AddFront(const CFileItemPtr &pItem, int itemPosition)
{
CSingleLock lock(m_lock);
if (itemPosition >= 0)
{
m_items.insert(m_items.begin()+itemPosition, pItem);
}
else
{
m_items.insert(m_items.begin()+(m_items.size()+itemPosition), pItem);
}
if (m_fastLookup)
{
m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath(), pItem));
}
}
void CFileItemList::Remove(CFileItem* pItem)
{
CSingleLock lock(m_lock);
for (IVECFILEITEMS it = m_items.begin(); it != m_items.end(); ++it)
{
if (pItem == it->get())
{
m_items.erase(it);
if (m_fastLookup)
{
m_map.erase(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath());
}
break;
}
}
}
void CFileItemList::Remove(int iItem)
{
CSingleLock lock(m_lock);
if (iItem >= 0 && iItem < (int)Size())
{
CFileItemPtr pItem = *(m_items.begin() + iItem);
if (m_fastLookup)
{
m_map.erase(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath());
}
m_items.erase(m_items.begin() + iItem);
}
}
void CFileItemList::Append(const CFileItemList& itemlist)
{
CSingleLock lock(m_lock);
for (int i = 0; i < itemlist.Size(); ++i)
Add(itemlist[i]);
}
void CFileItemList::Assign(const CFileItemList& itemlist, bool append)
{
CSingleLock lock(m_lock);
if (!append)
Clear();
Append(itemlist);
SetPath(itemlist.GetPath());
SetLabel(itemlist.GetLabel());
m_sortDetails = itemlist.m_sortDetails;
m_sortDescription = itemlist.m_sortDescription;
m_replaceListing = itemlist.m_replaceListing;
m_content = itemlist.m_content;
m_mapProperties = itemlist.m_mapProperties;
m_cacheToDisc = itemlist.m_cacheToDisc;
}
bool CFileItemList::Copy(const CFileItemList& items, bool copyItems /* = true */)
{
// assign all CFileItem parts
*(CFileItem*)this = *(CFileItem*)&items;
// assign the rest of the CFileItemList properties
m_replaceListing = items.m_replaceListing;
m_content = items.m_content;
m_mapProperties = items.m_mapProperties;
m_cacheToDisc = items.m_cacheToDisc;
m_sortDetails = items.m_sortDetails;
m_sortDescription = items.m_sortDescription;
m_sortIgnoreFolders = items.m_sortIgnoreFolders;
if (copyItems)
{
// make a copy of each item
for (int i = 0; i < items.Size(); i++)
{
CFileItemPtr newItem(new CFileItem(*items[i]));
Add(newItem);
}
}
return true;
}
CFileItemPtr CFileItemList::Get(int iItem)
{
CSingleLock lock(m_lock);
if (iItem > -1 && iItem < (int)m_items.size())
return m_items[iItem];
return CFileItemPtr();
}
const CFileItemPtr CFileItemList::Get(int iItem) const
{
CSingleLock lock(m_lock);
if (iItem > -1 && iItem < (int)m_items.size())
return m_items[iItem];
return CFileItemPtr();
}
CFileItemPtr CFileItemList::Get(const std::string& strPath)
{
CSingleLock lock(m_lock);
if (m_fastLookup)
{
IMAPFILEITEMS it = m_map.find(m_ignoreURLOptions ? CURL(strPath).GetWithoutOptions() : strPath);
if (it != m_map.end())
return it->second;
return CFileItemPtr();
}
// slow method...
for (unsigned int i = 0; i < m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (pItem->IsPath(m_ignoreURLOptions ? CURL(strPath).GetWithoutOptions() : strPath))
return pItem;
}
return CFileItemPtr();
}
const CFileItemPtr CFileItemList::Get(const std::string& strPath) const
{
CSingleLock lock(m_lock);
if (m_fastLookup)
{
std::map<std::string, CFileItemPtr>::const_iterator it = m_map.find(m_ignoreURLOptions ? CURL(strPath).GetWithoutOptions() : strPath);
if (it != m_map.end())
return it->second;
return CFileItemPtr();
}
// slow method...
for (unsigned int i = 0; i < m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (pItem->IsPath(m_ignoreURLOptions ? CURL(strPath).GetWithoutOptions() : strPath))
return pItem;
}
return CFileItemPtr();
}
int CFileItemList::Size() const
{
CSingleLock lock(m_lock);
return (int)m_items.size();
}
bool CFileItemList::IsEmpty() const
{
CSingleLock lock(m_lock);
return m_items.empty();
}
void CFileItemList::Reserve(int iCount)
{
CSingleLock lock(m_lock);
m_items.reserve(iCount);
}
void CFileItemList::Sort(FILEITEMLISTCOMPARISONFUNC func)
{
CSingleLock lock(m_lock);
std::stable_sort(m_items.begin(), m_items.end(), func);
}
void CFileItemList::FillSortFields(FILEITEMFILLFUNC func)
{
CSingleLock lock(m_lock);
std::for_each(m_items.begin(), m_items.end(), func);
}
void CFileItemList::Sort(SortBy sortBy, SortOrder sortOrder, SortAttribute sortAttributes /* = SortAttributeNone */)
{
if (sortBy == SortByNone ||
(m_sortDescription.sortBy == sortBy && m_sortDescription.sortOrder == sortOrder &&
m_sortDescription.sortAttributes == sortAttributes))
return;
SortDescription sorting;
sorting.sortBy = sortBy;
sorting.sortOrder = sortOrder;
sorting.sortAttributes = sortAttributes;
Sort(sorting);
m_sortDescription = sorting;
}
void CFileItemList::Sort(SortDescription sortDescription)
{
if (sortDescription.sortBy == SortByFile ||
sortDescription.sortBy == SortBySortTitle ||
sortDescription.sortBy == SortByDateAdded ||
sortDescription.sortBy == SortByRating ||
sortDescription.sortBy == SortByYear ||
sortDescription.sortBy == SortByPlaylistOrder ||
sortDescription.sortBy == SortByLastPlayed ||
sortDescription.sortBy == SortByPlaycount)
sortDescription.sortAttributes = (SortAttribute)((int)sortDescription.sortAttributes | SortAttributeIgnoreFolders);
if (sortDescription.sortBy == SortByNone ||
(m_sortDescription.sortBy == sortDescription.sortBy && m_sortDescription.sortOrder == sortDescription.sortOrder &&
m_sortDescription.sortAttributes == sortDescription.sortAttributes))
return;
if (m_sortIgnoreFolders)
sortDescription.sortAttributes = (SortAttribute)((int)sortDescription.sortAttributes | SortAttributeIgnoreFolders);
const Fields fields = SortUtils::GetFieldsForSorting(sortDescription.sortBy);
SortItems sortItems((size_t)Size());
for (int index = 0; index < Size(); index++)
{
sortItems[index] = std::shared_ptr<SortItem>(new SortItem);
m_items[index]->ToSortable(*sortItems[index], fields);
(*sortItems[index])[FieldId] = index;
}
// do the sorting
SortUtils::Sort(sortDescription, sortItems);
// apply the new order to the existing CFileItems
VECFILEITEMS sortedFileItems;
sortedFileItems.reserve(Size());
for (SortItems::const_iterator it = sortItems.begin(); it != sortItems.end(); it++)
{
CFileItemPtr item = m_items[(int)(*it)->at(FieldId).asInteger()];
// Set the sort label in the CFileItem
item->SetSortLabel((*it)->at(FieldSort).asWideString());
sortedFileItems.push_back(item);
}
// replace the current list with the re-ordered one
m_items = std::move(sortedFileItems);
}
void CFileItemList::Randomize()
{
CSingleLock lock(m_lock);
KODI::UTILS::RandomShuffle(m_items.begin(), m_items.end());
}
void CFileItemList::Archive(CArchive& ar)
{
CSingleLock lock(m_lock);
if (ar.IsStoring())
{
CFileItem::Archive(ar);
int i = 0;
if (!m_items.empty() && m_items[0]->IsParentFolder())
i = 1;
ar << (int)(m_items.size() - i);
ar << m_ignoreURLOptions;
ar << m_fastLookup;
ar << (int)m_sortDescription.sortBy;
ar << (int)m_sortDescription.sortOrder;
ar << (int)m_sortDescription.sortAttributes;
ar << m_sortIgnoreFolders;
ar << (int)m_cacheToDisc;
ar << (int)m_sortDetails.size();
for (unsigned int j = 0; j < m_sortDetails.size(); ++j)
{
const GUIViewSortDetails &details = m_sortDetails[j];
ar << (int)details.m_sortDescription.sortBy;
ar << (int)details.m_sortDescription.sortOrder;
ar << (int)details.m_sortDescription.sortAttributes;
ar << details.m_buttonLabel;
ar << details.m_labelMasks.m_strLabelFile;
ar << details.m_labelMasks.m_strLabelFolder;
ar << details.m_labelMasks.m_strLabel2File;
ar << details.m_labelMasks.m_strLabel2Folder;
}
ar << m_content;
for (; i < (int)m_items.size(); ++i)
{
CFileItemPtr pItem = m_items[i];
ar << *pItem;
}
}
else
{
CFileItemPtr pParent;
if (!IsEmpty())
{
CFileItemPtr pItem=m_items[0];
if (pItem->IsParentFolder())
pParent.reset(new CFileItem(*pItem));
}
SetIgnoreURLOptions(false);
SetFastLookup(false);
Clear();
CFileItem::Archive(ar);
int iSize = 0;
ar >> iSize;
if (iSize <= 0)
return ;
if (pParent)
{
m_items.reserve(iSize + 1);
m_items.push_back(pParent);
}
else
m_items.reserve(iSize);
bool ignoreURLOptions = false;
ar >> ignoreURLOptions;
bool fastLookup = false;
ar >> fastLookup;
int tempint;
ar >> (int&)tempint;
m_sortDescription.sortBy = (SortBy)tempint;
ar >> (int&)tempint;
m_sortDescription.sortOrder = (SortOrder)tempint;
ar >> (int&)tempint;
m_sortDescription.sortAttributes = (SortAttribute)tempint;
ar >> m_sortIgnoreFolders;
ar >> (int&)tempint;
m_cacheToDisc = CACHE_TYPE(tempint);
unsigned int detailSize = 0;
ar >> detailSize;
for (unsigned int j = 0; j < detailSize; ++j)
{
GUIViewSortDetails details;
ar >> (int&)tempint;
details.m_sortDescription.sortBy = (SortBy)tempint;
ar >> (int&)tempint;
details.m_sortDescription.sortOrder = (SortOrder)tempint;
ar >> (int&)tempint;
details.m_sortDescription.sortAttributes = (SortAttribute)tempint;
ar >> details.m_buttonLabel;
ar >> details.m_labelMasks.m_strLabelFile;
ar >> details.m_labelMasks.m_strLabelFolder;
ar >> details.m_labelMasks.m_strLabel2File;
ar >> details.m_labelMasks.m_strLabel2Folder;
m_sortDetails.push_back(details);
}
ar >> m_content;
for (int i = 0; i < iSize; ++i)
{
CFileItemPtr pItem(new CFileItem);
ar >> *pItem;
Add(pItem);
}
SetIgnoreURLOptions(ignoreURLOptions);
SetFastLookup(fastLookup);
}
}
void CFileItemList::FillInDefaultIcons()
{
CSingleLock lock(m_lock);
for (int i = 0; i < (int)m_items.size(); ++i)
{
CFileItemPtr pItem = m_items[i];
pItem->FillInDefaultIcon();
}
}
int CFileItemList::GetFolderCount() const
{
CSingleLock lock(m_lock);
int nFolderCount = 0;
for (int i = 0; i < (int)m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (pItem->m_bIsFolder)
nFolderCount++;
}
return nFolderCount;
}
int CFileItemList::GetObjectCount() const
{
CSingleLock lock(m_lock);
int numObjects = (int)m_items.size();
if (numObjects && m_items[0]->IsParentFolder())
numObjects--;
return numObjects;
}
int CFileItemList::GetFileCount() const
{
CSingleLock lock(m_lock);
int nFileCount = 0;
for (int i = 0; i < (int)m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (!pItem->m_bIsFolder)
nFileCount++;
}
return nFileCount;
}
int CFileItemList::GetSelectedCount() const
{
CSingleLock lock(m_lock);
int count = 0;
for (int i = 0; i < (int)m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (pItem->IsSelected())
count++;
}
return count;
}
void CFileItemList::FilterCueItems()
{
CSingleLock lock(m_lock);
// Handle .CUE sheet files...
std::vector<std::string> itemstodelete;
for (int i = 0; i < (int)m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (!pItem->m_bIsFolder)
{ // see if it's a .CUE sheet
if (pItem->IsCUESheet())
{
CCueDocumentPtr cuesheet(new CCueDocument);
if (cuesheet->ParseFile(pItem->GetPath()))
{
std::vector<std::string> MediaFileVec;
cuesheet->GetMediaFiles(MediaFileVec);
// queue the cue sheet and the underlying media file for deletion
for(std::vector<std::string>::iterator itMedia = MediaFileVec.begin(); itMedia != MediaFileVec.end(); itMedia++)
{
std::string strMediaFile = *itMedia;
std::string fileFromCue = strMediaFile; // save the file from the cue we're matching against,
// as we're going to search for others here...
bool bFoundMediaFile = CFile::Exists(strMediaFile);
if (!bFoundMediaFile)
{
// try file in same dir, not matching case...
if (Contains(strMediaFile))
{
bFoundMediaFile = true;
}
else
{
// try removing the .cue extension...
strMediaFile = pItem->GetPath();
URIUtils::RemoveExtension(strMediaFile);
CFileItem item(strMediaFile, false);
if (item.IsAudio() && Contains(strMediaFile))
{
bFoundMediaFile = true;
}
else
{ // try replacing the extension with one of our allowed ones.
std::vector<std::string> extensions = StringUtils::Split(g_advancedSettings.GetMusicExtensions(), "|");
for (std::vector<std::string>::const_iterator i = extensions.begin(); i != extensions.end(); ++i)
{
strMediaFile = URIUtils::ReplaceExtension(pItem->GetPath(), *i);
CFileItem item(strMediaFile, false);
if (!item.IsCUESheet() && !item.IsPlayList() && Contains(strMediaFile))
{
bFoundMediaFile = true;
break;
}
}
}
}
}
if (bFoundMediaFile)
{
cuesheet->UpdateMediaFile(fileFromCue, strMediaFile);
// apply CUE for later processing
for (int j = 0; j < (int)m_items.size(); j++)
{
CFileItemPtr pItem = m_items[j];
if (stricmp(pItem->GetPath().c_str(), strMediaFile.c_str()) == 0)
pItem->SetCueDocument(cuesheet);
}
}
}
}
itemstodelete.push_back(pItem->GetPath());
}
}
}
// now delete the .CUE files.
for (int i = 0; i < (int)itemstodelete.size(); i++)
{
for (int j = 0; j < (int)m_items.size(); j++)
{
CFileItemPtr pItem = m_items[j];
if (stricmp(pItem->GetPath().c_str(), itemstodelete[i].c_str()) == 0)
{ // delete this item
m_items.erase(m_items.begin() + j);
break;
}
}
}
}
// Remove the extensions from the filenames
void CFileItemList::RemoveExtensions()
{
CSingleLock lock(m_lock);
for (int i = 0; i < Size(); ++i)
m_items[i]->RemoveExtension();
}
void CFileItemList::Stack(bool stackFiles /* = true */)
{
CSingleLock lock(m_lock);
// not allowed here
if (IsVirtualDirectoryRoot() ||
IsLiveTV() ||
IsSourcesPath() ||
IsLibraryFolder())
return;
SetProperty("isstacked", true);
// items needs to be sorted for stuff below to work properly
Sort(SortByLabel, SortOrderAscending);
StackFolders();
if (stackFiles)
StackFiles();
}
void CFileItemList::StackFolders()
{
// Precompile our REs
VECCREGEXP folderRegExps;
CRegExp folderRegExp(true, CRegExp::autoUtf8);
const std::vector<std::string>& strFolderRegExps = g_advancedSettings.m_folderStackRegExps;
std::vector<std::string>::const_iterator strExpression = strFolderRegExps.begin();
while (strExpression != strFolderRegExps.end())
{
if (!folderRegExp.RegComp(*strExpression))
CLog::Log(LOGERROR, "%s: Invalid folder stack RegExp:'%s'", __FUNCTION__, strExpression->c_str());
else
folderRegExps.push_back(folderRegExp);
strExpression++;
}
if (!folderRegExp.IsCompiled())
{
CLog::Log(LOGDEBUG, "%s: No stack expressions available. Skipping folder stacking", __FUNCTION__);
return;
}
// stack folders
for (int i = 0; i < Size(); i++)
{
CFileItemPtr item = Get(i);
// combined the folder checks
if (item->m_bIsFolder)
{
// only check known fast sources?
// NOTES:
// 1. rars and zips may be on slow sources? is this supposed to be allowed?
if( !item->IsRemote()
|| item->IsSmb()
|| item->IsNfs()
|| URIUtils::IsInRAR(item->GetPath())
|| URIUtils::IsInZIP(item->GetPath())
|| URIUtils::IsOnLAN(item->GetPath())
)
{
// stack cd# folders if contains only a single video file
bool bMatch(false);
VECCREGEXP::iterator expr = folderRegExps.begin();
while (!bMatch && expr != folderRegExps.end())
{
//CLog::Log(LOGDEBUG,"%s: Running expression %s on %s", __FUNCTION__, expr->GetPattern().c_str(), item->GetLabel().c_str());
bMatch = (expr->RegFind(item->GetLabel().c_str()) != -1);
if (bMatch)
{
CFileItemList items;
CDirectory::GetDirectory(item->GetPath(),items,g_advancedSettings.m_videoExtensions);
// optimized to only traverse listing once by checking for filecount
// and recording last file item for later use
int nFiles = 0;
int index = -1;
for (int j = 0; j < items.Size(); j++)
{
if (!items[j]->m_bIsFolder)
{
nFiles++;
index = j;
}
if (nFiles > 1)
break;
}
if (nFiles == 1)
*item = *items[index];
}
expr++;
}
// check for dvd folders
if (!bMatch)
{
std::string dvdPath = item->GetOpticalMediaPath();
if (!dvdPath.empty())
{
// NOTE: should this be done for the CD# folders too?
item->m_bIsFolder = false;
item->SetPath(dvdPath);
item->SetLabel2("");
item->SetLabelPreformatted(true);
m_sortDescription.sortBy = SortByNone; /* sorting is now broken */
}
}
}
}
}
}
void CFileItemList::StackFiles()
{
// Precompile our REs
VECCREGEXP stackRegExps;
CRegExp tmpRegExp(true, CRegExp::autoUtf8);
const std::vector<std::string>& strStackRegExps = g_advancedSettings.m_videoStackRegExps;
std::vector<std::string>::const_iterator strRegExp = strStackRegExps.begin();
while (strRegExp != strStackRegExps.end())
{
if (tmpRegExp.RegComp(*strRegExp))
{
if (tmpRegExp.GetCaptureTotal() == 4)
stackRegExps.push_back(tmpRegExp);
else
CLog::Log(LOGERROR, "Invalid video stack RE (%s). Must have 4 captures.", strRegExp->c_str());
}
strRegExp++;
}
// now stack the files, some of which may be from the previous stack iteration
int i = 0;
while (i < Size())
{
CFileItemPtr item1 = Get(i);
// skip folders, nfo files, playlists
if (item1->m_bIsFolder
|| item1->IsParentFolder()
|| item1->IsNFO()
|| item1->IsPlayList()
)
{
// increment index
i++;
continue;
}
int64_t size = 0;
size_t offset = 0;
std::string stackName;
std::string file1;
std::string filePath;
std::vector<int> stack;
VECCREGEXP::iterator expr = stackRegExps.begin();
URIUtils::Split(item1->GetPath(), filePath, file1);
if (URIUtils::HasEncodedFilename(CURL(filePath)))
file1 = CURL::Decode(file1);
int j;
while (expr != stackRegExps.end())
{
if (expr->RegFind(file1, offset) != -1)
{
std::string Title1 = expr->GetMatch(1),
Volume1 = expr->GetMatch(2),
Ignore1 = expr->GetMatch(3),
Extension1 = expr->GetMatch(4);
if (offset)
Title1 = file1.substr(0, expr->GetSubStart(2));
j = i + 1;
while (j < Size())
{
CFileItemPtr item2 = Get(j);
// skip folders, nfo files, playlists
if (item2->m_bIsFolder
|| item2->IsParentFolder()
|| item2->IsNFO()
|| item2->IsPlayList()
)
{
// increment index
j++;
continue;
}
std::string file2, filePath2;
URIUtils::Split(item2->GetPath(), filePath2, file2);
if (URIUtils::HasEncodedFilename(CURL(filePath2)) )
file2 = CURL::Decode(file2);
if (expr->RegFind(file2, offset) != -1)
{
std::string Title2 = expr->GetMatch(1),
Volume2 = expr->GetMatch(2),
Ignore2 = expr->GetMatch(3),
Extension2 = expr->GetMatch(4);
if (offset)
Title2 = file2.substr(0, expr->GetSubStart(2));
if (StringUtils::EqualsNoCase(Title1, Title2))
{
if (!StringUtils::EqualsNoCase(Volume1, Volume2))
{
if (StringUtils::EqualsNoCase(Ignore1, Ignore2) &&
StringUtils::EqualsNoCase(Extension1, Extension2))
{
if (stack.empty())
{
stackName = Title1 + Ignore1 + Extension1;
stack.push_back(i);
size += item1->m_dwSize;
}
stack.push_back(j);
size += item2->m_dwSize;
}
else // Sequel
{
offset = 0;
expr++;
break;
}
}
else if (!StringUtils::EqualsNoCase(Ignore1, Ignore2)) // False positive, try again with offset
{
offset = expr->GetSubStart(3);
break;
}
else // Extension mismatch
{
offset = 0;
expr++;
break;
}
}
else // Title mismatch
{
offset = 0;
expr++;
break;
}
}
else // No match 2, next expression
{
offset = 0;
expr++;
break;
}
j++;
}
if (j == Size())
expr = stackRegExps.end();
}
else // No match 1
{
offset = 0;
expr++;
}
if (stack.size() > 1)
{
// have a stack, remove the items and add the stacked item
// dont actually stack a multipart rar set, just remove all items but the first
std::string stackPath;
if (Get(stack[0])->IsRAR())
stackPath = Get(stack[0])->GetPath();
else
{
CStackDirectory dir;
stackPath = dir.ConstructStackPath(*this, stack);
}
item1->SetPath(stackPath);
// clean up list
for (unsigned k = 1; k < stack.size(); k++)
Remove(i+1);
// item->m_bIsFolder = true; // don't treat stacked files as folders
// the label may be in a different char set from the filename (eg over smb
// the label is converted from utf8, but the filename is not)
if (!CServiceBroker::GetSettings().GetBool(CSettings::SETTING_FILELISTS_SHOWEXTENSIONS))
URIUtils::RemoveExtension(stackName);
item1->SetLabel(stackName);
item1->m_dwSize = size;
break;
}
}
i++;
}
}
bool CFileItemList::Load(int windowID)
{
CFile file;
auto path = GetDiscFileCache(windowID);
try
{
if (file.Open(path))
{
CArchive ar(&file, CArchive::load);
ar >> *this;
CLog::Log(LOGDEBUG,"Loading items: %i, directory: %s sort method: %i, ascending: %s", Size(), CURL::GetRedacted(GetPath()).c_str(), m_sortDescription.sortBy,
m_sortDescription.sortOrder == SortOrderAscending ? "true" : "false");
ar.Close();
file.Close();
return true;
}
}
catch(std::out_of_range ex)
{
CLog::Log(LOGERROR, "Corrupt archive: %s", CURL::GetRedacted(path).c_str());
}
return false;
}
bool CFileItemList::Save(int windowID)
{
int iSize = Size();
if (iSize <= 0)
return false;
CLog::Log(LOGDEBUG,"Saving fileitems [%s]", CURL::GetRedacted(GetPath()).c_str());
CFile file;
if (file.OpenForWrite(GetDiscFileCache(windowID), true)) // overwrite always
{
CArchive ar(&file, CArchive::store);
ar << *this;
CLog::Log(LOGDEBUG," -- items: %i, sort method: %i, ascending: %s", iSize, m_sortDescription.sortBy, m_sortDescription.sortOrder == SortOrderAscending ? "true" : "false");
ar.Close();
file.Close();
return true;
}
return false;
}
void CFileItemList::RemoveDiscCache(int windowID) const
{
std::string cacheFile(GetDiscFileCache(windowID));
if (CFile::Exists(cacheFile))
{
CLog::Log(LOGDEBUG,"Clearing cached fileitems [%s]", CURL::GetRedacted(GetPath()).c_str());
CFile::Delete(cacheFile);
}
}
std::string CFileItemList::GetDiscFileCache(int windowID) const
{
std::string strPath(GetPath());
URIUtils::RemoveSlashAtEnd(strPath);
uint32_t crc = Crc32::ComputeFromLowerCase(strPath);
std::string cacheFile;
if (IsCDDA() || IsOnDVD())
return StringUtils::Format("special://temp/archive_cache/r-%08x.fi", crc);
if (IsMusicDb())
return StringUtils::Format("special://temp/archive_cache/mdb-%08x.fi", crc);
if (IsVideoDb())
return StringUtils::Format("special://temp/archive_cache/vdb-%08x.fi", crc);
if (IsSmartPlayList())
return StringUtils::Format("special://temp/archive_cache/sp-%08x.fi", crc);
if (windowID)
return StringUtils::Format("special://temp/archive_cache/%i-%08x.fi", windowID, crc);
return StringUtils::Format("special://temp/archive_cache/%08x.fi", crc);
}
bool CFileItemList::AlwaysCache() const
{
// some database folders are always cached
if (IsMusicDb())
return CMusicDatabaseDirectory::CanCache(GetPath());
if (IsVideoDb())
return CVideoDatabaseDirectory::CanCache(GetPath());
if (IsEPG())
return true; // always cache
return false;
}
std::string CFileItem::GetUserMusicThumb(bool alwaysCheckRemote /* = false */, bool fallbackToFolder /* = false */) const
{
if (m_strPath.empty()
|| StringUtils::StartsWithNoCase(m_strPath, "newsmartplaylist://")
|| StringUtils::StartsWithNoCase(m_strPath, "newplaylist://")
|| m_bIsShareOrDrive
|| IsInternetStream()
|| URIUtils::IsUPnP(m_strPath)
|| (URIUtils::IsFTP(m_strPath) && !g_advancedSettings.m_bFTPThumbs)
|| IsPlugin()
|| IsAddonsPath()
|| IsLibraryFolder()
|| IsParentFolder()
|| IsMusicDb())
return "";
// we first check for <filename>.tbn or <foldername>.tbn
std::string fileThumb(GetTBNFile());
if (CFile::Exists(fileThumb))
return fileThumb;
// Fall back to folder thumb, if requested
if (!m_bIsFolder && fallbackToFolder)
{
CFileItem item(URIUtils::GetDirectory(m_strPath), true);
return item.GetUserMusicThumb(alwaysCheckRemote);
}
// if a folder, check for folder.jpg
if (m_bIsFolder && !IsFileFolder() && (!IsRemote() || alwaysCheckRemote || CServiceBroker::GetSettings().GetBool(CSettings::SETTING_MUSICFILES_FINDREMOTETHUMBS)))
{
std::vector<std::string> thumbs = StringUtils::Split(g_advancedSettings.m_musicThumbs, "|");
for (std::vector<std::string>::const_iterator i = thumbs.begin(); i != thumbs.end(); ++i)
{
std::string folderThumb(GetFolderThumb(*i));
if (CFile::Exists(folderThumb))
{
return folderThumb;
}
}
}
// No thumb found
return "";
}
// Gets the .tbn filename from a file or folder name.
// <filename>.ext -> <filename>.tbn
// <foldername>/ -> <foldername>.tbn
std::string CFileItem::GetTBNFile() const
{
std::string thumbFile;
std::string strFile = m_strPath;
if (IsStack())
{
std::string strPath, strReturn;
URIUtils::GetParentPath(m_strPath,strPath);
CFileItem item(CStackDirectory::GetFirstStackedFile(strFile),false);
std::string strTBNFile = item.GetTBNFile();
strReturn = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(strTBNFile));
if (CFile::Exists(strReturn))
return strReturn;
strFile = URIUtils::AddFileToFolder(strPath,URIUtils::GetFileName(CStackDirectory::GetStackedTitlePath(strFile)));
}
if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
{
std::string strPath = URIUtils::GetDirectory(strFile);
std::string strParent;
URIUtils::GetParentPath(strPath,strParent);
strFile = URIUtils::AddFileToFolder(strParent, URIUtils::GetFileName(m_strPath));
}
CURL url(strFile);
strFile = url.GetFileName();
if (m_bIsFolder && !IsFileFolder())
URIUtils::RemoveSlashAtEnd(strFile);
if (!strFile.empty())
{
if (m_bIsFolder && !IsFileFolder())
thumbFile = strFile + ".tbn"; // folder, so just add ".tbn"
else
thumbFile = URIUtils::ReplaceExtension(strFile, ".tbn");
url.SetFileName(thumbFile);
thumbFile = url.Get();
}
return thumbFile;
}
bool CFileItem::SkipLocalArt() const
{
return (m_strPath.empty()
|| StringUtils::StartsWithNoCase(m_strPath, "newsmartplaylist://")
|| StringUtils::StartsWithNoCase(m_strPath, "newplaylist://")
|| m_bIsShareOrDrive
|| IsInternetStream()
|| URIUtils::IsUPnP(m_strPath)
|| (URIUtils::IsFTP(m_strPath) && !g_advancedSettings.m_bFTPThumbs)
|| IsPlugin()
|| IsAddonsPath()
|| IsLibraryFolder()
|| IsParentFolder()
|| IsLiveTV()
|| IsPVRRecording()
|| IsDVD());
}
std::string CFileItem::FindLocalArt(const std::string &artFile, bool useFolder) const
{
if (SkipLocalArt())
return "";
std::string thumb;
if (!m_bIsFolder)
{
thumb = GetLocalArt(artFile, false);
if (!thumb.empty() && CFile::Exists(thumb))
return thumb;
}
if ((useFolder || (m_bIsFolder && !IsFileFolder())) && !artFile.empty())
{
std::string thumb2 = GetLocalArt(artFile, true);
if (!thumb2.empty() && thumb2 != thumb && CFile::Exists(thumb2))
return thumb2;
}
return "";
}
std::string CFileItem::GetLocalArt(const std::string &artFile, bool useFolder) const
{
// no retrieving of empty art files from folders
if (useFolder && artFile.empty())
return "";
std::string strFile = m_strPath;
if (IsStack())
{
/* CFileItem item(CStackDirectory::GetFirstStackedFile(strFile),false);
std::string localArt = item.GetLocalArt(artFile);
return localArt;
*/
std::string strPath;
URIUtils::GetParentPath(m_strPath,strPath);
strFile = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(CStackDirectory::GetStackedTitlePath(strFile)));
}
if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
{
std::string strPath = URIUtils::GetDirectory(strFile);
std::string strParent;
URIUtils::GetParentPath(strPath,strParent);
strFile = URIUtils::AddFileToFolder(strParent, URIUtils::GetFileName(strFile));
}
if (IsMultiPath())
strFile = CMultiPathDirectory::GetFirstPath(m_strPath);
if (IsOpticalMediaFile())
{ // optical media files should be treated like folders
useFolder = true;
strFile = GetLocalMetadataPath();
}
else if (useFolder && !(m_bIsFolder && !IsFileFolder()))
strFile = URIUtils::GetDirectory(strFile);
if (strFile.empty()) // empty filepath -> nothing to find
return "";
if (useFolder)
{
if (!artFile.empty())
return URIUtils::AddFileToFolder(strFile, artFile);
}
else
{
if (artFile.empty()) // old thumbnail matching
return URIUtils::ReplaceExtension(strFile, ".tbn");
else
return URIUtils::ReplaceExtension(strFile, "-" + artFile);
}
return "";
}
std::string CFileItem::GetFolderThumb(const std::string &folderJPG /* = "folder.jpg" */) const
{
std::string strFolder = m_strPath;
if (IsStack() ||
URIUtils::IsInRAR(strFolder) ||
URIUtils::IsInZIP(strFolder))
{
URIUtils::GetParentPath(m_strPath,strFolder);
}
if (IsMultiPath())
strFolder = CMultiPathDirectory::GetFirstPath(m_strPath);
if (IsPlugin())
return "";
return URIUtils::AddFileToFolder(strFolder, folderJPG);
}
std::string CFileItem::GetMovieName(bool bUseFolderNames /* = false */) const
{
if (IsLabelPreformatted())
return GetLabel();
if (m_pvrRecordingInfoTag)
return m_pvrRecordingInfoTag->m_strTitle;
else if (CUtil::IsTVRecording(m_strPath))
{
std::string title = CPVRRecording::GetTitleFromURL(m_strPath);
if (!title.empty())
return title;
}
std::string strMovieName = GetBaseMoviePath(bUseFolderNames);
if (URIUtils::IsStack(strMovieName))
strMovieName = CStackDirectory::GetStackedTitlePath(strMovieName);
URIUtils::RemoveSlashAtEnd(strMovieName);
return CURL::Decode(URIUtils::GetFileName(strMovieName));
}
std::string CFileItem::GetBaseMoviePath(bool bUseFolderNames) const
{
std::string strMovieName = m_strPath;
if (IsMultiPath())
strMovieName = CMultiPathDirectory::GetFirstPath(m_strPath);
if (IsOpticalMediaFile())
return GetLocalMetadataPath();
if (bUseFolderNames &&
(!m_bIsFolder || URIUtils::IsInArchive(m_strPath) ||
(HasVideoInfoTag() && GetVideoInfoTag()->m_iDbId > 0 && !CMediaTypes::IsContainer(GetVideoInfoTag()->m_type))))
{
std::string name2(strMovieName);
URIUtils::GetParentPath(name2,strMovieName);
if (URIUtils::IsInArchive(m_strPath))
{
std::string strArchivePath;
URIUtils::GetParentPath(strMovieName, strArchivePath);
strMovieName = strArchivePath;
}
}
return strMovieName;
}
std::string CFileItem::GetLocalFanart() const
{
if (IsVideoDb())
{
if (!HasVideoInfoTag())
return ""; // nothing can be done
CFileItem dbItem(m_bIsFolder ? GetVideoInfoTag()->m_strPath : GetVideoInfoTag()->m_strFileNameAndPath, m_bIsFolder);
return dbItem.GetLocalFanart();
}
std::string strFile2;
std::string strFile = m_strPath;
if (IsStack())
{
std::string strPath;
URIUtils::GetParentPath(m_strPath,strPath);
CStackDirectory dir;
std::string strPath2;
strPath2 = dir.GetStackedTitlePath(strFile);
strFile = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(strPath2));
CFileItem item(dir.GetFirstStackedFile(m_strPath),false);
std::string strTBNFile(URIUtils::ReplaceExtension(item.GetTBNFile(), "-fanart"));
strFile2 = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(strTBNFile));
}
if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
{
std::string strPath = URIUtils::GetDirectory(strFile);
std::string strParent;
URIUtils::GetParentPath(strPath,strParent);
strFile = URIUtils::AddFileToFolder(strParent, URIUtils::GetFileName(m_strPath));
}
// no local fanart available for these
if (IsInternetStream()
|| URIUtils::IsUPnP(strFile)
|| URIUtils::IsBluray(strFile)
|| IsLiveTV()
|| IsPlugin()
|| IsAddonsPath()
|| IsDVD()
|| (URIUtils::IsFTP(strFile) && !g_advancedSettings.m_bFTPThumbs)
|| m_strPath.empty())
return "";
std::string strDir = URIUtils::GetDirectory(strFile);
if (strDir.empty())
return "";
CFileItemList items;
CDirectory::GetDirectory(strDir, items, g_advancedSettings.GetPictureExtensions(), DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_READ_CACHE | DIR_FLAG_NO_FILE_INFO);
if (IsOpticalMediaFile())
{ // grab from the optical media parent folder as well
CFileItemList moreItems;
CDirectory::GetDirectory(GetLocalMetadataPath(), moreItems, g_advancedSettings.GetPictureExtensions(), DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_READ_CACHE | DIR_FLAG_NO_FILE_INFO);
items.Append(moreItems);
}
std::vector<std::string> fanarts = StringUtils::Split(g_advancedSettings.m_fanartImages, "|");
strFile = URIUtils::ReplaceExtension(strFile, "-fanart");
fanarts.insert(m_bIsFolder ? fanarts.end() : fanarts.begin(), URIUtils::GetFileName(strFile));
if (!strFile2.empty())
fanarts.insert(m_bIsFolder ? fanarts.end() : fanarts.begin(), URIUtils::GetFileName(strFile2));
for (std::vector<std::string>::const_iterator i = fanarts.begin(); i != fanarts.end(); ++i)
{
for (int j = 0; j < items.Size(); j++)
{
std::string strCandidate = URIUtils::GetFileName(items[j]->m_strPath);
URIUtils::RemoveExtension(strCandidate);
std::string strFanart = *i;
URIUtils::RemoveExtension(strFanart);
if (StringUtils::EqualsNoCase(strCandidate, strFanart))
return items[j]->m_strPath;
}
}
return "";
}
std::string CFileItem::GetLocalMetadataPath() const
{
if (m_bIsFolder && !IsFileFolder())
return m_strPath;
std::string parent(URIUtils::GetParentPath(m_strPath));
std::string parentFolder(parent);
URIUtils::RemoveSlashAtEnd(parentFolder);
parentFolder = URIUtils::GetFileName(parentFolder);
if (StringUtils::EqualsNoCase(parentFolder, "VIDEO_TS") || StringUtils::EqualsNoCase(parentFolder, "BDMV"))
{ // go back up another one
parent = URIUtils::GetParentPath(parent);
}
return parent;
}
bool CFileItem::LoadMusicTag()
{
// not audio
if (!IsAudio())
return false;
// already loaded?
if (HasMusicInfoTag() && m_musicInfoTag->Loaded())
return true;
// check db
CMusicDatabase musicDatabase;
if (musicDatabase.Open())
{
CSong song;
if (musicDatabase.GetSongByFileName(m_strPath, song))
{
GetMusicInfoTag()->SetSong(song);
SetArt("thumb", song.strThumb);
return true;
}
musicDatabase.Close();
}
// load tag from file
CLog::Log(LOGDEBUG, "%s: loading tag information for file: %s", __FUNCTION__, m_strPath.c_str());
CMusicInfoTagLoaderFactory factory;
std::unique_ptr<IMusicInfoTagLoader> pLoader (factory.CreateLoader(*this));
if (pLoader.get() != NULL)
{
if (pLoader->Load(m_strPath, *GetMusicInfoTag()))
return true;
}
// no tag - try some other things
if (IsCDDA())
{
// we have the tracknumber...
int iTrack = GetMusicInfoTag()->GetTrackNumber();
if (iTrack >= 1)
{
std::string strText = g_localizeStrings.Get(554); // "Track"
if (!strText.empty() && strText[strText.size() - 1] != ' ')
strText += " ";
std::string strTrack = StringUtils::Format((strText + "%i").c_str(), iTrack);
GetMusicInfoTag()->SetTitle(strTrack);
GetMusicInfoTag()->SetLoaded(true);
return true;
}
}
else
{
std::string fileName = URIUtils::GetFileName(m_strPath);
URIUtils::RemoveExtension(fileName);
for (unsigned int i = 0; i < g_advancedSettings.m_musicTagsFromFileFilters.size(); i++)
{
CLabelFormatter formatter(g_advancedSettings.m_musicTagsFromFileFilters[i], "");
if (formatter.FillMusicTag(fileName, GetMusicInfoTag()))
{
GetMusicInfoTag()->SetLoaded(true);
return true;
}
}
}
return false;
}
bool CFileItem::LoadGameTag()
{
// Already loaded?
if (HasGameInfoTag() && m_gameInfoTag->IsLoaded())
return true;
//! @todo
GetGameInfoTag();
m_gameInfoTag->SetLoaded(true);
return false;
}
void CFileItemList::Swap(unsigned int item1, unsigned int item2)
{
if (item1 != item2 && item1 < m_items.size() && item2 < m_items.size())
std::swap(m_items[item1], m_items[item2]);
}
bool CFileItemList::UpdateItem(const CFileItem *item)
{
if (!item)
return false;
CSingleLock lock(m_lock);
for (unsigned int i = 0; i < m_items.size(); i++)
{
CFileItemPtr pItem = m_items[i];
if (pItem->IsSamePath(item))
{
pItem->UpdateInfo(*item);
return true;
}
}
return false;
}
void CFileItemList::AddSortMethod(SortBy sortBy, int buttonLabel, const LABEL_MASKS &labelMasks, SortAttribute sortAttributes /* = SortAttributeNone */)
{
AddSortMethod(sortBy, sortAttributes, buttonLabel, labelMasks);
}
void CFileItemList::AddSortMethod(SortBy sortBy, SortAttribute sortAttributes, int buttonLabel, const LABEL_MASKS &labelMasks)
{
SortDescription sorting;
sorting.sortBy = sortBy;
sorting.sortAttributes = sortAttributes;
AddSortMethod(sorting, buttonLabel, labelMasks);
}
void CFileItemList::AddSortMethod(SortDescription sortDescription, int buttonLabel, const LABEL_MASKS &labelMasks)
{
GUIViewSortDetails sort;
sort.m_sortDescription = sortDescription;
sort.m_buttonLabel = buttonLabel;
sort.m_labelMasks = labelMasks;
m_sortDetails.push_back(sort);
}
void CFileItemList::SetReplaceListing(bool replace)
{
m_replaceListing = replace;
}
void CFileItemList::ClearSortState()
{
m_sortDescription.sortBy = SortByNone;
m_sortDescription.sortOrder = SortOrderNone;
m_sortDescription.sortAttributes = SortAttributeNone;
}
bool CFileItem::HasVideoInfoTag() const
{
// Note: CPVRRecording is derived from CVideoInfoTag
return m_pvrRecordingInfoTag.get() != nullptr || m_videoInfoTag != nullptr;
}
CVideoInfoTag* CFileItem::GetVideoInfoTag()
{
// Note: CPVRRecording is derived from CVideoInfoTag
if (m_pvrRecordingInfoTag)
return m_pvrRecordingInfoTag.get();
else if (!m_videoInfoTag)
m_videoInfoTag = new CVideoInfoTag;
return m_videoInfoTag;
}
const CVideoInfoTag* CFileItem::GetVideoInfoTag() const
{
// Note: CPVRRecording is derived from CVideoInfoTag
return m_pvrRecordingInfoTag ? m_pvrRecordingInfoTag.get() : m_videoInfoTag;
}
CPictureInfoTag* CFileItem::GetPictureInfoTag()
{
if (!m_pictureInfoTag)
m_pictureInfoTag = new CPictureInfoTag;
return m_pictureInfoTag;
}
MUSIC_INFO::CMusicInfoTag* CFileItem::GetMusicInfoTag()
{
if (!m_musicInfoTag)
m_musicInfoTag = new MUSIC_INFO::CMusicInfoTag;
return m_musicInfoTag;
}
CGameInfoTag* CFileItem::GetGameInfoTag()
{
if (!m_gameInfoTag)
m_gameInfoTag = new CGameInfoTag;
return m_gameInfoTag;
}
std::string CFileItem::FindTrailer() const
{
std::string strFile2;
std::string strFile = m_strPath;
if (IsStack())
{
std::string strPath;
URIUtils::GetParentPath(m_strPath,strPath);
CStackDirectory dir;
std::string strPath2;
strPath2 = dir.GetStackedTitlePath(strFile);
strFile = URIUtils::AddFileToFolder(strPath,URIUtils::GetFileName(strPath2));
CFileItem item(dir.GetFirstStackedFile(m_strPath),false);
std::string strTBNFile(URIUtils::ReplaceExtension(item.GetTBNFile(), "-trailer"));
strFile2 = URIUtils::AddFileToFolder(strPath,URIUtils::GetFileName(strTBNFile));
}
if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
{
std::string strPath = URIUtils::GetDirectory(strFile);
std::string strParent;
URIUtils::GetParentPath(strPath,strParent);
strFile = URIUtils::AddFileToFolder(strParent,URIUtils::GetFileName(m_strPath));
}
// no local trailer available for these
if (IsInternetStream()
|| URIUtils::IsUPnP(strFile)
|| URIUtils::IsBluray(strFile)
|| IsLiveTV()
|| IsPlugin()
|| IsDVD())
return "";
std::string strDir = URIUtils::GetDirectory(strFile);
CFileItemList items;
CDirectory::GetDirectory(strDir, items, g_advancedSettings.m_videoExtensions, DIR_FLAG_READ_CACHE | DIR_FLAG_NO_FILE_INFO | DIR_FLAG_NO_FILE_DIRS);
URIUtils::RemoveExtension(strFile);
strFile += "-trailer";
std::string strFile3 = URIUtils::AddFileToFolder(strDir, "movie-trailer");
// Precompile our REs
VECCREGEXP matchRegExps;
CRegExp tmpRegExp(true, CRegExp::autoUtf8);
const std::vector<std::string>& strMatchRegExps = g_advancedSettings.m_trailerMatchRegExps;
std::vector<std::string>::const_iterator strRegExp = strMatchRegExps.begin();
while (strRegExp != strMatchRegExps.end())
{
if (tmpRegExp.RegComp(*strRegExp))
{
matchRegExps.push_back(tmpRegExp);
}
strRegExp++;
}
std::string strTrailer;
for (int i = 0; i < items.Size(); i++)
{
std::string strCandidate = items[i]->m_strPath;
URIUtils::RemoveExtension(strCandidate);
if (StringUtils::EqualsNoCase(strCandidate, strFile) ||
StringUtils::EqualsNoCase(strCandidate, strFile2) ||
StringUtils::EqualsNoCase(strCandidate, strFile3))
{
strTrailer = items[i]->m_strPath;
break;
}
else
{
VECCREGEXP::iterator expr = matchRegExps.begin();
while (expr != matchRegExps.end())
{
if (expr->RegFind(strCandidate) != -1)
{
strTrailer = items[i]->m_strPath;
i = items.Size();
break;
}
expr++;
}
}
}
return strTrailer;
}
int CFileItem::GetVideoContentType() const
{
VIDEODB_CONTENT_TYPE type = VIDEODB_CONTENT_MOVIES;
if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeTvShow)
type = VIDEODB_CONTENT_TVSHOWS;
if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeEpisode)
return VIDEODB_CONTENT_EPISODES;
if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeMusicVideo)
return VIDEODB_CONTENT_MUSICVIDEOS;
CVideoDatabaseDirectory dir;
VIDEODATABASEDIRECTORY::CQueryParams params;
dir.GetQueryParams(m_strPath, params);
if (params.GetSetId() != -1 && params.GetMovieId() == -1) // movie set
return VIDEODB_CONTENT_MOVIE_SETS;
return type;
}
CFileItem CFileItem::GetItemToPlay() const
{
if (HasEPGInfoTag())
{
const CPVRChannelPtr channel(GetEPGInfoTag()->ChannelTag());
if (channel)
return CFileItem(channel);
}
return *this;
}
CBookmark CFileItem::GetResumePoint() const
{
if (HasVideoInfoTag())
return GetVideoInfoTag()->GetResumePoint();
return CBookmark();
}
bool CFileItem::IsResumePointSet() const
{
return GetResumePoint().IsSet();
}
double CFileItem::GetCurrentResumeTime() const
{
return lrint(GetResumePoint().timeInSeconds);
}
bool CFileItem::GetCurrentResumeTimeAndPartNumber(int& startOffset, int& partNumber) const
{
CBookmark resumePoint(GetResumePoint());
if (resumePoint.IsSet())
{
startOffset = lrint(resumePoint.timeInSeconds);
partNumber = resumePoint.partNumber;
return true;
}
return false;
}
| [
"rodrigosoaresilva@gmail.com"
] | rodrigosoaresilva@gmail.com |
8967951225bd3ab17f875522958e652e36182f8b | 8e30b5f6f8847fc49ded87bed2bf7dc09167f99e | /world.cpp | c89c2481bae962e5ea70fca00c48cc90d021ac60 | [] | no_license | rockerbacon/pacman-ia | f98dc902ac41d0e15bbbfde3f07a3ff573214f60 | eb012341e3edc4429c7e7ba78eb31849c226e9f3 | refs/heads/master | 2021-08-28T21:57:16.896945 | 2017-12-13T07:29:10 | 2017-12-13T07:29:10 | 113,363,111 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,981 | cpp | #include "world.h"
#include <iostream>
#include <fstream>
#include <math.h>
#include <SDL2/SDL.h>
using namespace lab309;
#define COLLISION_BOX_X_TOLERANCE 0.55
#define COLLISION_BOX_Y_TOLERANCE 0.55
#define QUEUEDMOVE_WINDOW 400
const Vector<int> Object::directions[4] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
/*WORLD*/
World::Cell::Cell (void) {
this->contents = 0;
this->trailTimeStamp = 0;
this->ghostTrailTimeStamp = 0;
}
World::Cell::Cell (int contents) {
this->contents = contents;
this->trailTimeStamp = 0;
this->ghostTrailTimeStamp = 0;
}
World::World (const Window &window, size_t navmeshWidth, size_t navmeshHeight) {
this->window = &window;
this->navmesh = Matrix<Cell>(navmeshHeight, navmeshWidth);
for (size_t i = 0; i < navmeshHeight; i++) {
for (size_t j = 0; j < navmeshWidth; j++) {
this->navmesh[i][j] = Cell();
}
}
}
World::World (const Window &window) {
this->window = &window;
}
Vector<int> World::mapToNavmesh (const Vector<float> &pos) const {
if (pos[_X] < 0 || pos[_Y] < 0) {
return {-1, -1};
}
int i, j;
int cellWidth = this->getCellWidth();
int cellHeight = this->getCellHeight();
Vector<int> v = (Vector<int>)pos;
v[_X] = (v[_X] - v[_X] % this->getCellWidth())/this->getCellWidth();
v[_Y] = (v[_Y] - v[_Y] % this->getCellHeight())/this->getCellHeight();
return v;
}
Vector<float> World::mapToPixel (const Vector<int> &pos) const {
Vector<float> pixel(2);
pixel[_X] = pos[_X]*this->getCellWidth();
pixel[_Y] = pos[_Y]*this->getCellHeight();
return pixel;
}
int World::getCellWidth (void) const {
return this->window->getWidth()/this->navmesh.getColums();
}
int World::getCellHeight (void) const {
return this->window->getHeight()/this->navmesh.getLines();
}
World::Cell World::getCell (const Vector<int> &pos) const {
if (pos[_X] >= 0 && pos[_X] < this->navmesh.getColums() && pos[_Y] >= 0 && pos[_Y] < this->navmesh.getLines()) {
return this->navmesh[pos];
}
return Cell(WALL_ID);
}
size_t World::getWidth (void) const {
return this->navmesh.getColums();
}
size_t World::getHeight (void) const {
return this->navmesh.getLines();
}
void World::add (int id, const Vector<int> &pos) {
if (pos[_X] >= 0 && pos[_X] < this->navmesh.getColums() && pos[_Y] >= 0 && pos[_Y] < this->navmesh.getLines()) {
this->navmesh[pos].contents |= id;
}
}
std::list<Vector<float>> World::getFromMesh (int content) const {
Vector<int> pos(2);
std::list<Vector<float>> l;
for (pos[_Y] = 0; pos[_Y] < this->navmesh.getLines(); pos[_Y]++) {
for (pos[_X] = 0; pos[_X] < this->navmesh.getColums(); pos[_X]++) {
if ((this->navmesh[pos].contents & content) == content) {
l.push_front(this->mapToPixel(pos));
}
}
}
return l;
}
void World::remove (int id, const Vector<int> &pos) {
if (pos[_X] >= 0 && pos[_X] < this->navmesh.getColums() && pos[_Y] >= 0 && pos[_Y] < this->navmesh.getLines()) {
//std::cout << this->navmesh[pos].contents << std::endl; //debug
this->navmesh[pos].contents &= ~id;
//std::cout << this->navmesh[pos].contents << std::endl; //debug
}
}
void World::setTrail (unsigned long int timeStamp, const Vector<int> &cell) {
this->navmesh[cell].trailTimeStamp = timeStamp;
}
void World::setGhostTrail (unsigned long int timeStamp, const Vector<int> &cell) {
if (cell[_X] >= 0 && cell[_Y] >= 0 && cell[_X] < this->getWidth() && cell[_Y] < this->getHeight()) {
this->navmesh[cell].ghostTrailTimeStamp = timeStamp;
}
}
bool World::readFromFile (const char *filePath) {
std::fstream input;
size_t meshWidth, meshHeight;
char c;
input.open(filePath, std::fstream::in);
if (input.fail()) {
return false;
}
input >> meshWidth;
input >> meshHeight;
this->navmesh = Matrix<Cell>(meshWidth, meshHeight);
for (size_t i = 0; i < this->navmesh.getLines(); i++) {
for (size_t j = 0; j < this->navmesh.getColums(); j++) {
//ignorar espacos, tabs e fins de linha
do {
input >> c;
} while (c==' '||c=='\n'||c=='\t');
//preencher celula da malha
switch(c) {
case WALL_CELL:
this->navmesh[j][i].contents = WALL_ID;
break;
case PACMAN_CELL:
this->navmesh[j][i].contents = PACMAN_ID|PATHWAY_ID;
break;
case GHOST_CELL:
this->navmesh[j][i].contents = GHOST_ID|PATHWAY_ID;
break;
case PILL_CELL:
this->navmesh[j][i].contents = PILL_ID|PATHWAY_ID;
break;
case SUPERPILL_CELL:
this->navmesh[j][i].contents = SUPERPILL_ID|PATHWAY_ID;
break;
default:
this->navmesh[j][i].contents = 0;
break;
}
}
}
return true;
}
/*OBJECT*/
Object::Object (SDL_Surface *texture, int rectWidth, int rectHeight, int displayWidth, int displayHeight, World *world, int id, float speed, const Vector<float> &initialPos) : Sprite(texture, rectWidth, rectHeight, displayWidth, displayHeight) {
this->world = world;
this->id = id;
this->speed = speed;
this->setPos(initialPos);
this->currentCell = world->mapToNavmesh(initialPos);
this->moveDirection = {0, 0};
this->queuedMove = false;
}
void Object::setMoveDirection (const Vector<int> &moveDirection) {
if (this->moveDirection == -1*moveDirection || this->fitsCell() && this->canMove(moveDirection)) {
this->moveDirection = moveDirection;
this->queuedMove = false;
} else {
this->moveDirectionQueue = moveDirection;
this->queuedMove = true;
this->queuedMoveTimeStamp = SDL_GetTicks();
}
}
bool Object::canMove (const Vector<int> &moveDirection) const {
World::Cell c = this->world->getCell(this->currentCell+moveDirection);
return (c.contents & WALL_ID) == 0 && (c.contents & this->id) == 0;
}
float Object::getSpeed (void) const {
return this->speed;
}
Vector<int> Object::getCurrentCell (void) const {
return this->currentCell;
}
bool Object::fitsCell (void) const {
Vector<float> corners[4];
Vector<float> center = this->getCenter();
float xOffset = (float)this->getDisplayWidth()*(1.0-COLLISION_BOX_X_TOLERANCE);
float yOffset = (float)this->getDisplayHeight()*(1.0-COLLISION_BOX_Y_TOLERANCE);
bool fits;
size_t i;
corners[0] = center+Vector<float>({xOffset, yOffset});
corners[1] = center+Vector<float>({-xOffset, yOffset});
corners[2] = center+Vector<float>({xOffset, -yOffset});
corners[3] = center+Vector<float>({-xOffset, -yOffset});
fits = true;
i = 0;
while(fits && i < 3) {
if (this->world->mapToNavmesh(corners[i]) != this->world->mapToNavmesh(corners[i+1])) {
fits = false;
}
i++;
}
return fits;
}
Vector<int> Object::getMoveDirection (void) const {
return this->moveDirection;
}
void Object::move (Sprite *wall, unsigned long int currentTime, double elapsedTime) {
bool fits = this->fitsCell();
//if (this->id & PACMAN_ID) std::cout << SDL_GetTicks() - this->queuedMoveTimeStamp << std::endl; //debug
if (fits && this->queuedMove && currentTime - this->queuedMoveTimeStamp < QUEUEDMOVE_WINDOW) {
this->setMoveDirection(this->moveDirectionQueue);
}
if (!fits || this->canMove(this->moveDirection)) {
Vector<float> oldPosition = this->getPos();
Vector<int> oldCell = this->currentCell;
Vector<int> nextCell = this->currentCell+this->moveDirection;
this->translate(Vector<float>(this->speed*elapsedTime*this->moveDirection));
this->currentCell = this->world->mapToNavmesh(this->getCenter());
if (oldCell != this->currentCell) {
//safeguard for excessive movement that may happen if the elapsed time is too big
wall->setPos(this->world->mapToPixel(nextCell));
if ((this->world->getCell(nextCell).contents & WALL_ID) && collision((Sprite)(*this), *wall)) {
this->setPos(this->world->mapToPixel(oldCell));
this->currentCell = oldCell;
} else {
this->world->remove(this->id, oldCell);
this->world->add(this->id, this->currentCell);
if (this->id & PACMAN_ID) {
this->world->setTrail(currentTime, oldCell);
} else if (this->id & GHOST_ID) {
this->world->setGhostTrail(currentTime, oldCell);
}
}
}
}
}
void Object::setSpeed (float speed) {
this->speed = speed;
}
| [
"mp8andrade@hotmail.com"
] | mp8andrade@hotmail.com |
27dcda2f1fb569c9ff607024f5556fa99806afe4 | 40352c91f77a5190669b9ce98f053b6a63396f55 | /Server_UDP/server_udp/main.cpp | 5b5b3ddf272f6d409f985f7656590328785239cd | [] | no_license | Lmx2315/M54_modul | 0d8351d5c13ff537ae208eabdeac8a36daeb1d71 | 65cf2aa31adce4b0843abf5aa4ccd26179b950ef | refs/heads/master | 2021-07-07T14:23:43.136946 | 2021-04-30T11:51:01 | 2021-04-30T11:51:04 | 236,025,374 | 1 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 6,204 | cpp | #include <stdio.h>
#include <winsock2.h> // Wincosk2.h должен быть раньше windows!
#include <windows.h>
#include <locale.h>
#pragma comment(lib, "ws2_32.lib")
#define MY_PORT 666 // Порт, который слушает сервер 666
// макрос для печати количества активных пользователей
#define PRINTNUSERS if (nclients) printf("%d user on-line\n", nclients); \
else printf("No User on line\n");
// прототип функции, обслуживающий подключившихся пользователей
DWORD WINAPI SexToClient(LPVOID client_socket);
// глобальная переменная - количество активных пользователей
int nclients = 0;
int main()
{
setlocale(0,"");
char buff[1024]; // Буфер для различных нужд
printf("TCP SERVER \n");
// Шаг 1 - Инициализация Библиотеки Сокетов
// т.к. возвращенная функцией информация не используется
// ей передается указатель на рабочий буфер, преобразуемый к указателю
// на структуру WSADATA.
// Такой прием позволяет сэкономить одну переменную, однако, буфер
// должен быть не менее полкилобайта размером (структура WSADATA
// занимает 400 байт)
if (WSAStartup(0x0202, (WSADATA *)&buff[0]))
{
// Ошибка!
printf("Error WSAStartup %d\n", WSAGetLastError());
return -1;
}
// Шаг 2 - создание сокета
SOCKET mysocket;
// AF_INET - сокет Интернета
// SOCK_STREAM - потоковый сокет (с установкой соединения)
// 0 - по умолчанию выбирается TCP протокол
if ((mysocket = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
// Ошибка!
printf("Error socket %d\n", WSAGetLastError());
WSACleanup(); // Деиницилизация библиотеки Winsock
return -1;
}
// Шаг 3 - связывание сокета с локальным адресом
sockaddr_in local_addr;
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(MY_PORT); // не забываем о сетевом порядке!!!
local_addr.sin_addr.s_addr = 0; // сервер принимает подключения
// на все свои IP-адреса
// вызываем bind для связывания
if (bind(mysocket, (sockaddr *)&local_addr, sizeof(local_addr)))
{
// Ошибка
printf("Error bind %d\n", WSAGetLastError());
closesocket(mysocket); // закрываем сокет!
WSACleanup();
return -1;
}
// Шаг 4 - ожидание подключений
// размер очереди - 0x100
if (listen(mysocket, 0x100))
{
// Ошибка
printf("Error listen %d\n", WSAGetLastError());
closesocket(mysocket);
WSACleanup();
return -1;
}
printf("Ожидание подключений...\n");
// Шаг 5 - извлекаем сообщение из очереди
SOCKET client_socket; // сокет для клиента
sockaddr_in client_addr; // адрес клиента (заполняется системой)
// функции accept необходимо передать размер структуры
int client_addr_size = sizeof(client_addr);
// цикл извлечения запросов на подключение из очереди
while ((client_socket = accept(mysocket, (sockaddr *)&client_addr, \
&client_addr_size)))
{
nclients++; // увеличиваем счетчик подключившихся клиентов
// пытаемся получить имя хоста
HOSTENT *hst;
hst = gethostbyaddr((char *)&client_addr. sin_addr.s_addr, 4, AF_INET);
// вывод сведений о клиенте
printf("+%s [%s] new connect!\n",
(hst) ? hst->h_name : "", inet_ntoa(client_addr.sin_addr));
PRINTNUSERS
// Вызов нового потока для обслужвания клиента
// Да, для этого рекомендуется использовать _beginthreadex
// но, поскольку никаких вызовов функций стандартной Си библиотеки
// поток не делает, можно обойтись и CreateThread
DWORD thID;
CreateThread(NULL, NULL, SexToClient, &client_socket, NULL, &thID);
}
return 0;
}
// Эта функция создается в отдельном потоке
// и обсуживает очередного подключившегося клиента независимо от остальных
DWORD WINAPI SexToClient(LPVOID client_socket)
{
SOCKET my_sock;
my_sock = ((SOCKET *)client_socket)[0];
char buff[20 * 1024];
#define sHELLO "Hello, Sailor\r\n"
// отправляем клиенту приветствие
send(my_sock, sHELLO, sizeof(sHELLO), 0);
// цикл эхо-сервера: прием строки от клиента и возвращение ее клиенту
int bytes_recv;
while ((bytes_recv = recv(my_sock, &buff[0], sizeof(buff), 0)) &&
bytes_recv != SOCKET_ERROR)
send(my_sock, &buff[0], bytes_recv, 0);
// если мы здесь, то произошел выход из цикла по причине
// возращения функцией recv ошибки - соединение с клиентом разорвано
nclients--; // уменьшаем счетчик активных клиентов
printf("-disconnect\n"); PRINTNUSERS
// закрываем сокет
closesocket(my_sock);
return 0;
}
| [
"lmx2315@mail.ru"
] | lmx2315@mail.ru |
f2e8ab2fd97f17465b2701521bf122a243d8f33b | 7c8bc1e5163b7c7de4ca9c45248ea55e55278456 | /DP/test-因子/test-因子/test-因子.cpp | 3bcccf12e324fd0c10ca88ff0838e458cfbe39d7 | [] | no_license | playerxq/DP | fcf62b052efc7500368571005876129b24cbd585 | 7478b76edf351ebbfbd61dc2e7950a875b3bfbc5 | refs/heads/master | 2020-06-29T06:33:34.035960 | 2018-08-01T12:58:22 | 2018-08-01T12:58:22 | 74,444,132 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 3,294 | cpp | // test-因子.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <cstdio>
#include <iostream>
#include <string.h>
#include <math.h>
#include <vector>
#include <queue>
#include<iomanip>
#include <ctype.h>
#include <climits>
#include <algorithm>
using namespace std;
/*
int d[100];
int main()
{
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
int n;
scanf("%d",&n);
d[1] = 1;
for(int i = 2;i<=n;i++)
{
for(int j = 2;j<=i;j++)
if(i%j==0)
d[i]+=d[i/j];
}
printf("%d",d[n]);
return 0;
}
*/
/*
#define MAXN 50
int G[MAXN][MAXN];
int v,e;
int x[MAXN];
int bestx[MAXN];
int cn;
int best;
void init()
{
scanf("%d",&v);
for(int i = 1;i<=v;i++)
{
for(int j = 1;j<=v;j++)
scanf("%d",&G[i][j]);
x[i]=0;
bestx[i]=0;
}
best=cn=0;
}
void backtrack(int i)
{
if(i>v)
{
if(cn>best)
{
for(int j = 1;j<=v;j++)
bestx[j]=x[j];
best=cn;
}
return;
}
int ok = 1;
for(int j = 1;j<i;j++)
{
if(x[j]&&(G[i][j]==0&&G[j][i]==0))
{
ok = 0;
break;
}
}
if(ok)
{
x[i]=1;
cn++;
backtrack(i+1);
x[i]=0;
cn--;
}
if(cn+v-i>best)
{
x[i]=0;
backtrack(i+1);
}
}
void main()
{
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
init();
backtrack(1);
for(int i = 1;i<=v;i++)
{
if(bestx[i])
printf("%d ",i);
}
printf("\n");
printf("%d\n",best);
}
*/
#define MAXN 50
int v,e;
int bestn,cn;
int G[MAXN][MAXN];
int x[MAXN];
int bestx[MAXN];
void init()
{
scanf("%d",&v);
for(int i = 1;i<=v;i++)
{
for(int j = 1;j<=v;j++)
scanf("%d",&G[i][j]);
x[i]=0;
bestx[i]=0;
}
bestn=cn=0;
}
struct BBNode
{
BBNode *parent; //指向父结点的指针
bool LChild; //左儿子结点标志
};
struct CliqueNode //定义优先队列类型为CliqueNode
{
int cnum; //当前团的顶点数
int un; //当前团最大顶点数的上界
int level; //结点在子集空间树种所处的层次
BBNode *p; //指向活结点在子集树中相应结点的指针
bool operator<(const CliqueNode &b) const //<号重载建立大根堆
{
if (b.un>un) return true;
if (b.un==un&& b.cnum>cnum) return true;
else return false;
}
};
void BBMaxClique()
{
BBNode *E=new(BBNode);
int j,i=1;
int cnum=0;
int OK=1;
priority_queue<CliqueNode> Q;
E->LChild=false; //初始化
E->parent=NULL;
while(i!=v+1)
{
OK = 1;
BBNode *B=E;
for(j=i-1;j>0;B=B->parent,j--)
{
if(B->LChild&&G[i][j]==0&&G[j][i]==0)
{
OK = 0;
break;
}
}
if(OK)
{
CliqueNode *D=new(CliqueNode);
D->p=new(BBNode);
if(cnum+1>bestn)bestn=cnum+1;
D->cnum=cnum+1;
D->level=i+1;
D->p->LChild=true;
D->p->parent=E;
D->un=cnum+1+v-i;
Q.push(*D); //进队列
}
if(cnum+v-i>bestn)
{
CliqueNode *D=new(CliqueNode);
D->p=new(BBNode);
D->cnum=cnum;
D->level=i+1;
D->p->LChild=false;
D->p->parent=E;
D->un=cnum+v-i;
Q.push(*D); //进队列
}
CliqueNode N;
N=Q.top();
Q.pop();
E=N.p;
cnum=N.cnum;
i = N.level;
}
for(j=v;j>0;j--) //保存最优解
{
bestx[j]=E->LChild;
E=E->parent;
bestn=cnum;
}
}
void main()
{
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
init();
BBMaxClique();
for(int i = 1;i<=v;i++)
{
if(bestx[i])
printf("%d ",i);
}
printf("\n");
printf("%d\n",bestn);
} | [
"1062842783@qq.com"
] | 1062842783@qq.com |
0772094d8245e09a21453aded386ee73a5411052 | dec9f9c8e2a67c8ae6353c7daea10095f8682882 | /Trees/BST/LCA.cpp | b236f71d3ad1fd227bed8e3651af73646efc38a0 | [] | no_license | vishalsalgond/Data-Structures-Algorithms | f86fa106ffb5c846f9a0c0a2cac4175b7696a386 | 1225d46220c0f3d009c5c0e186e88974a1e2fe12 | refs/heads/master | 2023-03-27T02:29:08.569305 | 2021-03-25T12:34:31 | 2021-03-25T12:34:31 | 263,601,551 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 417 | cpp | //https://practice.geeksforgeeks.org/problems/lowest-common-ancestor-in-a-bst/1
Node* LCA(Node *root, int p, int q)
{
Node* ans = NULL;
while(root) {
int x = root -> data;
if(x < p && x < q) {
root = root -> right;
}
else if (x > p && x > q) {
root = root -> left;
}
else {
ans = root;
break;
}
}
return ans;
}
| [
"noreply@github.com"
] | noreply@github.com |
385145fbff0c7a62c10107709ddc458e4a202671 | c19350447f843621844f230c6d8f6a9c819dfb59 | /lab1x1/helper.cpp | 9553d9d77abe2c90bebcdde9526a85f59ea20ba2 | [] | no_license | Jim-Holmstroem/cprog10 | 8d255d00c37b0db06028ca3f2b477d08c9834e9e | ed73b87231c17900aed30a0ae4fe94354a3864bb | refs/heads/master | 2021-01-13T02:04:13.680487 | 2013-01-26T17:43:06 | 2013-01-26T17:43:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 693 | cpp | #include "helper.h"
Vector<std::string>& Helper::split(std::string str, std::string delim, Vector<std::string>& results){
int cutAt;
while( (cutAt = str.find_first_of(delim)) != str.npos ){
if(cutAt > 0){
results.push_back(str.substr(0,cutAt));
}
str = str.substr(cutAt+1);
}
if(str.length() > 0){ //slatten
results.push_back(str);
}
return results;
}
//TODO: fixa med referenspekare och new och liknande för att det ska funka "på riktigt"
Vector<std::string>& Helper::split(std::string str, std::string delim){
Vector<std::string>* results = new Vector<std::string>();
return Helper::split(str,delim,*results);
}
| [
"jim.holmstroem@gmail.com"
] | jim.holmstroem@gmail.com |
1d7b2fe2b1aea0bf4b02778580718b857b62307e | 64d35f5517962bbf04f9274be51ac2afac356921 | /LLOneMaker/parser.h | f06769b53a9bf6ef3f88dbeaaabf0ac25aac8373 | [] | no_license | lightyears1998/angelica-c | 5998a45eb5878da6ab6737b7e22dd33082504e1e | 79789cd601c5216b2adf8db374a09ade7b6a00ae | refs/heads/master | 2021-12-01T06:53:16.511163 | 2021-11-27T11:10:46 | 2021-11-27T11:10:46 | 183,536,718 | 9 | 0 | null | null | null | null | GB18030 | C++ | false | false | 446 | h | // parser.h
//
// 从输入流中获得终结符、非终结符和文法结构符号的Parser。
#pragma once
#include "common.h"
#include <vector>
#include <iostream>
namespace angelica
{
using namespace std;
class Parser
{
private:
istream &in_;
public:
Parser(istream& in) : in_(in) {};
~Parser() = default;
// 从输入流中解析单词符号，直到遇到换行符。
vector<Symbol> ParseLineFromInputStream();
};
}
| [
"lightyears1998@hotmail.com"
] | lightyears1998@hotmail.com |
6f74238b33c7b92c362329ca00d3b4710848be2c | 4c53f1c2b38ab97531be88828cbae38e3aa5e951 | /components/services/paint_preview_compositor/paint_preview_compositor_collection_impl.h | 4e4688c6cc1b2a02b3ea2486fccbf3020586bfe3 | [
"BSD-3-Clause"
] | permissive | piotrzarycki/chromium | 7d1e8c688986d962eecbd1b5d2ca93e1d167bd29 | f9965cd785ea5898a2f84d9a7c05054922e02988 | refs/heads/master | 2023-02-26T03:58:58.895546 | 2019-11-13T18:09:45 | 2019-11-13T18:09:45 | 221,524,087 | 1 | 0 | BSD-3-Clause | 2019-11-13T18:19:59 | 2019-11-13T18:19:59 | null | UTF-8 | C++ | false | false | 2,988 | h | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_SERVICES_PAINT_PREVIEW_COMPOSITOR_PAINT_PREVIEW_COMPOSITOR_COLLECTION_IMPL_H_
#define COMPONENTS_SERVICES_PAINT_PREVIEW_COMPOSITOR_PAINT_PREVIEW_COMPOSITOR_COLLECTION_IMPL_H_
#include <memory>
#include "base/callback.h"
#include "base/containers/flat_map.h"
#include "base/macros.h"
#include "base/memory/scoped_refptr.h"
#include "base/single_thread_task_runner.h"
#include "base/unguessable_token.h"
#include "components/discardable_memory/client/client_discardable_shared_memory_manager.h"
#include "components/services/paint_preview_compositor/paint_preview_compositor_impl.h"
#include "components/services/paint_preview_compositor/public/mojom/paint_preview_compositor.mojom.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/receiver.h"
namespace discardable_memory {
class ClientDiscardableSharedMemoryManager;
}
namespace paint_preview {
class PaintPreviewCompositorCollectionImpl
: public mojom::PaintPreviewCompositorCollection {
public:
// Create a new PaintPreviewCompositorCollectionImpl bound to |receiver| (can
// be nullptr for tests). Will attempt to initialize required font access if
// |initialize_environment| is true. |io_task_runner| is used by the
// discardable memory manager client for operations on shared memory.
PaintPreviewCompositorCollectionImpl(
mojo::PendingReceiver<mojom::PaintPreviewCompositorCollection> receiver,
bool initialize_environment,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
~PaintPreviewCompositorCollectionImpl() override;
// PaintPreviewCompositorCollection implementation.
void SetDiscardableSharedMemoryManager(
mojo::PendingRemote<
discardable_memory::mojom::DiscardableSharedMemoryManager> manager)
override;
void CreateCompositor(
mojo::PendingReceiver<mojom::PaintPreviewCompositor> compositor,
CreateCompositorCallback callback) override;
void ListCompositors(ListCompositorsCallback callback) override;
private:
// Invoked by a |compositor| when it is disconnected from its remote. Used to
// delete the corresponding instance from |compositors_|.
void OnDisconnect(const base::UnguessableToken& id);
mojo::Receiver<mojom::PaintPreviewCompositorCollection> receiver_{this};
const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
std::unique_ptr<discardable_memory::ClientDiscardableSharedMemoryManager>
discardable_shared_memory_manager_;
base::flat_map<base::UnguessableToken,
std::unique_ptr<PaintPreviewCompositorImpl>>
compositors_;
DISALLOW_COPY_AND_ASSIGN(PaintPreviewCompositorCollectionImpl);
};
} // namespace paint_preview
#endif // COMPONENTS_SERVICES_PAINT_PREVIEW_COMPOSITOR_PAINT_PREVIEW_COMPOSITOR_COLLECTION_IMPL_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
b77fd1f8eece30f8a1a7d6b5cdfd03d4f1d4d765 | 8d087ccbe4717c7c5b09bca20b5a3efd80a07ab0 | /The Space Wars/Temp/StagingArea/Data/il2cppOutput/mscorlib_System_Threading_EventResetMode204462409.h | 87b5a7cc04704515d082ed0555132ccae169200f | [] | no_license | RandomProduct/SpaceWars2 | 6e51a60352ad8691e927692f271450158d42111f | 028241db123499410319293b80d1974be00e915d | refs/heads/master | 2021-01-01T05:17:26.058675 | 2016-05-20T22:54:52 | 2016-05-20T22:54:52 | 59,331,031 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 974 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "mscorlib_System_Enum285998070.h"
#include "mscorlib_System_Threading_EventResetMode204462409.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Threading.EventResetMode
struct EventResetMode_t204462409
{
public:
// System.Int32 System.Threading.EventResetMode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(EventResetMode_t204462409, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"ream@uwec.edu"
] | ream@uwec.edu |
f8cc9135a0d3df28ef1d3dc9a574321aac664bc1 | 0115857fd3db4ac104095c35299f54429780f88f | /Scada/Dialog/Linkage/DialogLinkage.h | 0e57f26ad0c9a2177939a2e513bcbe48b8dba566 | [] | no_license | Blackrose/QT | 329319fa2938320790e0df45a366de661a34f9a6 | 2aed4c46978b807b257ac098c4738e6ec2333b3c | refs/heads/master | 2021-12-12T13:24:16.560207 | 2017-01-16T02:06:23 | 2017-01-16T02:06:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,384 | h | #ifndef DIALOG_LINKAGE_H
#define DIALOG_LINKAGE_H
#include "../Scada/Src/Scene/Scene.h"
#include "../Scada/Src/Item/Item.h"
#include "../Scada/Src/Service/Service.h"
#include "../Scada/Src/Linkage/Linkage.h"
#include "../Scada/Src/TableView/TableView.h"
#include "../Scada/Src/Base/Base.h"
class DialogLinkage : public QDialog
{
Q_OBJECT
public:
DialogLinkage(const QList<TScene *> &SceneList, const QList<TService *> &ServiceList,
QList<TLinkage *> &LinkageList, QWidget *parent = 0);
~DialogLinkage();
bool mInit;
bool mSave;
QList<TLinkage *> mLinkageList;
private slots:
void fAdd();
void fEdit();
void fDel();
void fTableClick(int Row, int Col);
void fOkClicked();
private:
// 表格
QLabel *mLabelTableShow;
TTableView *mTable;
// src
QLabel *mLabelSrcServiceShow;
QComboBox *mComboBoxSrcService;
QLabel *mLabelSrcNodeId;
QComboBox *mComboBoxSrcNodeId;
QLabel *mLabelSrcNodeIdText;
// dst
QLabel *mLabelDstServiceShow;
QComboBox *mComboBoxDstService;
QLabel *mLabelDstNodeId;
QComboBox *mComboBoxDstNodeId;
QLabel *mLabelDstNodeIdText;
//
QPushButton *mButtonAdd;
QPushButton *mButtonEdit;
QPushButton *mButtonDel;
QPushButton *mButtonOk;
QPushButton *mButtonClose;
bool fCheckMsg();
};
#endif // DIALOG_LINKAGE_H
| [
"18511834487@163.com"
] | 18511834487@163.com |
b15d7aa4b16fa020f30348e4c6eb881e7708a1f9 | 58549d2d1dfd7bdafa188d8f3e1924686a7a4fa6 | /Assignment/9/bonus/polyMath.cpp | 316f93f1ae741418038146a070d60fb29f0e59d8 | [] | no_license | cptalpdeniz/CPSC2150 | 492f0ee272e8185139fcdd3e60bcc1e288744b3a | bc7a8f0e1cfd7824f95355e00eb11a30d8aaac37 | refs/heads/master | 2023-01-28T19:24:47.691979 | 2020-12-09T18:19:48 | 2020-12-09T18:19:48 | 295,884,595 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,249 | cpp | // Program to use (test) univariate polynomials with a user interface.
// Commands supported
// -> input two polynomials
// -> calculate their sum
// -> get the coefficients of some terms
// -> get the degree of the polynomial
// -> evaluate the polynomial given a specific value for x.
// -> get the number of terms in the polynomial
// -> possibly differentiate
// All the input from a user comes from standard input (std::cin) and the output
// with results and questions for the user are done to standard output (std::cout).
// usage: polyMath -batch < inFile.txt > outFile.txt
// to run program non-interactively obtaining data from inFile.txt
// putting the output into outFile.txt
//
// usage: polyMath
// renders an interactive session with commands
// Author: Gladys Monagan (with material from Jian hua Pan)
// DO NOT POST THIS ANYWHERE.
// This code is copyrighted.
// Use it exclusively for CPSC 2150 at Langara College in Vancouver
#include "Univariate.h"
#include "Commands.h"
#include <functional> // std::greater
#include <map> // std::map
#include <iostream> // std::cout std::cin
#include <string> // std::string
using std::cout, std::string, std::cin;
// output to standard output a polynomial with its label
// precondition:
// the operator << has been overloaded for Univariate
void printPoly(const string& label, const Univariate& poly) {
cout << label << " = " << poly << "\n";
}
// output to standard output the polynomial's degree with its label
void printDegree(const string& label, const Univariate& poly) {
cout << "degree of " << label << " = " << poly.degree() << "\n";
}
// output to standard output the polynomials a and b
// precondition:
// aPoly, bPoly are bona fide polynomials
// (including the zero polynomial)
void printPolys(const Univariate& aPoly, const Univariate& bPoly) {
printPoly("a", aPoly);
printPoly("b", bPoly);
printDegree("a", aPoly);
printDegree("b", bPoly);
}
void differentiate(const Univariate& aPoly, const Univariate& bPoly) {
cout << "********************differentiate is not implemented*********\n";
// printPoly("da/dx", aPoly.differentiate());
// printPoly("db/dx", bPoly.differentiate());
printPoly("da/dx", aPoly);
printPoly("db/dx", bPoly);
}
// output to standard output the coefficient and degree with a blurb
void printCoeffDegree(string label, int coefficient, int degree) {
cout << "in " << label << ", " << coefficient;
cout << " is the coefficient of the term of degree " << degree << "\n";
}
// output to standard output the polynomials a, b and their sum
// precondition:
// aPoly, bPoly and sumPoly are bona fide polynomials
// (including the zero polynomial)
void printPolys(const Univariate& aPoly, const Univariate& bPoly, const Univariate& sumPoly) {
printPoly("a", aPoly);
printPoly("b", bPoly);
printPoly("a+b", sumPoly);
printDegree("a", aPoly);
printDegree("b", bPoly);
printDegree("a+b", sumPoly);
}
// output to standard output the number of terms of the aPoly, bPoly and sumPoly if validSum
// validSum means that sumPoly is a valid polynomial
// precondition:
// aPoly, bPoly, sumPoly are bona fide polynomials
// (including the zero polynomial)
void numberOfTerms(const Univariate& aPoly, const Univariate& bPoly,
const Univariate& sumPoly, bool validSum) {
cout << aPoly.numberOfTerms() << " term(s) in a = " << aPoly << "\n";
cout << bPoly.numberOfTerms() << " term(s) in b = " << bPoly << "\n";
if (validSum)
cout << sumPoly.numberOfTerms() << " term(s) in sum = " << sumPoly<<"\n";
}
// read from standard input the info on the first polynomial (polynomial a)
// if successful, read the info on the second polynomial (polynomial b)
// expected for each polynomial is
// -> the number of terms
// -> pairs of numbers corresponding to the coefficient of the term and the degree
// precondition:
// aPoly, bPoly, sumPoly are the zero polynomials
// the operator << has been defined for Univariates
// reading into a polynomial consists of
// an integer n for the number of terms
// coefficient degree pairs n times
// postcondition:
// aPoly, bPoly are bona fide polynomials
// the input stream cin is cleared in case of having read non-numeric input
bool inputUnivariates(Univariate& aPoly, Univariate& bPoly) {
bool successfulRead = true;
cout << "for polynomial a, enter # of terms,";
cout << " then \"coefficient degree\" pairs:\n";
if (!(std::cin >> aPoly)) {
cout << "ERROR in reading polynomial a\n";
successfulRead = false;
}
if (successfulRead) {
cout << "for polynomial b, enter # of terms,";
cout << " then \"coefficient degree\" pairs:\n";
if (!(std::cin >> bPoly)) {
cout << "ERROR in reading polynomial b\n";
successfulRead = false;
}
}
clearClean(cin);
return successfulRead;
}
// read from standard input the degree of the term whose coefficients will be printed
// for aPoly, bPoly and sumPoly (if validSum is true)
// if validSum is true, that means that sumPoly is valid
// if notInteractive is true, the degree read is echoed to standard output
// postcondition:
// the input stream cin is cleared in case of having read non-numeric input
void getCoeffs(const Univariate& aPoly, const Univariate& bPoly,
const Univariate& sumPoly, bool validSum, bool notInteractive) {
do {
int degree;
cout << "enter degree of polynomial term whose coefficient is needed ";
cin >> degree;
if (notInteractive) cout << degree << "\n";
printCoeffDegree("a", aPoly.coefficient(degree), degree);
printCoeffDegree("b", bPoly.coefficient(degree), degree);
if (validSum) printCoeffDegree("a+b", sumPoly.coefficient(degree), degree);
cout << "continue getting coefficients? (y/n): ";
} while (yesAnswer(notInteractive));
clearClean(cin);
}
// read from standard input the value of x to use in evaluating the polynomials
// evaluate aPoly, bPoly and sumPoly (if validSum is true) with the given value of x
// and output the results
// if validSum is true, that means that sumPoly is valid
// if notInteractive is true, the read read is echoed to standard output
// postcondition:
// the input stream cin is cleared in case of having read non-numeric input
void evalPolys(const Univariate& aPoly, const Univariate& bPoly,
const Univariate& sumPoly, bool validSum, bool notInteractive) {
do {
double x;
cout << "enter the value of x: ";
cin >> x;
if (notInteractive) cout << x << "\n";
cout << "when x = " << x << "\n";
cout << "a = " << aPoly << " = " << aPoly.evaluate(x) << "\n";
cout << "b = " << bPoly << " = " << bPoly.evaluate(x) << "\n";
if (validSum) cout << "a+b = " << sumPoly << " = " << sumPoly.evaluate(x) << "\n";
cout << "evaluate for another value of x? (y/n) : ";
} while (yesAnswer(notInteractive));
clearClean(cin);
}
// process the command
// read into aPoly and bPoly
// compute the polynomial which is the sum of aPoly and bPoly
// print aPoly, bPoly and sumPoly
// evaluate aPoly, bPoly and sumPoly asking the user for the value of x
// get the coefficients of terms in aPoly, bPoly and sumPoly
// get the number of terms in aPoly, bPoly and sumPoly
// print to standard output if an error was made
// read a comment (or document) and echo it if necessary
// postcondition:
// return true when the command is RESET or QUIT, returns false otherwise
// validSum is set to true if the command SUM is executed
//
bool process(Commands command, bool notInteractive, Univariate& aPoly,
Univariate& bPoly, Univariate& sumPoly, bool& validSum) {
bool doneProcessing = false;
switch (command) {
case INPUT:
// using the overloaded operator << of Univariate to enter info
if (inputUnivariates(aPoly, bPoly)) printPolys(aPoly, bPoly);
break;
case SUM:
validSum = true;
sumPoly = aPoly + bPoly;
printPolys(aPoly, bPoly, sumPoly);
break;
case PRINT:
validSum ? printPolys(aPoly, bPoly, sumPoly) : printPolys(aPoly,bPoly);
break;
case EVALUATE:
// ask the user for the values of x and evaluate the polynomials
evalPolys(aPoly, bPoly, sumPoly, validSum, notInteractive);
break;
case GET_COEFF:
// ask for the degree of the term whose coefficient will be returned
getCoeffs(aPoly, bPoly, sumPoly, validSum, notInteractive);
break;
case NUMBER_OF_TERMS:
// output the number of terms of each polynomial
numberOfTerms(aPoly, bPoly, sumPoly, validSum);
break;
case RESET:
// will be used to restart the process eliminating the polynomials
doneProcessing = true;
break;
case MENTION:
getLineOutputLine(cin, cout, notInteractive);
break;
case DIFFERENTIATE:
differentiate(aPoly, bPoly);
break;
case QUIT:
// the task is done
doneProcessing = true;
break;
case INVALID:
cout << "invalid command, please input again!\n";
break;
default:
std::cerr << "**** ERROR in the switch of processCommand ***\n";
break;
}
return doneProcessing;
}
// determine if the "-batch" option was entered meaning that the
// session is NOT interactive
// return true if the string matches -batch, false otherwise
bool notInteractiveOption(string option) {
return option == "-batch";
}
// build the tree so that the degree is in descending order
struct MyFunctor {
bool operator() (int a, int b) const {
return a > b;
}
};
// if the session is interactive, echo the input
// for each pair of polynomials read, process the command and
// finish once the command is quit
int main(int argc, char* argv[]) {
bool notInteractive = false;
if (argc > 1) {
notInteractive = notInteractiveOption(argv[1]);
}
std::map<char, Commands> commands;
buildCommands(commands);
Commands cmd;
do {
if (!notInteractive) printCommandMenu();
// process two polynomials (and their sum)
bool doneWithPolys = false;
// with a lambda function
Univariate aPoly([](int a, int b) -> bool {return a > b;});
// with a default STL function
Univariate bPoly((std::greater<int>()));
// with a functor or function object
MyFunctor descending;
Univariate sumPoly(descending);
bool validSum = false; // set to true when the command is SUM
do {
cmd = getCommand(commands, notInteractive);
doneWithPolys = process(cmd,notInteractive,aPoly,bPoly,sumPoly,validSum);
} while (!doneWithPolys); // calls the destructors
} while (cmd != QUIT);
return 0;
}
| [
"something@something.local"
] | something@something.local |
98138ad28524711c4f61bd78ef7b8717be837ba9 | f2b3dfca6c2e270dbfef3304b86a21ad01446124 | /Easy/NthDigit.cpp | a29114c3755ed33b71e58231b7c36755b8aba26a | [] | no_license | Lihit/LeetCode | 96ab31dd711e3ef18858f12a9911d4bd75a61432 | 60fb9b307a9aa9cd214c4e668807d0aaee52c62b | refs/heads/master | 2021-09-11T13:46:13.730972 | 2018-04-08T06:49:57 | 2018-04-08T06:49:57 | 105,347,926 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,050 | cpp | /*Find the nth digit of the infinite integer sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...
Note:
n is positive and will fit within the range of a 32-bit signed integer (n < 231).
Example 1:
Input:
3
Output:
3
Example 2:
Input:
11
Output:
0
Explanation:
The 11th digit of the sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... is a 0, which is part of the number 10.*/
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;
class Solution {
public:
int findNthDigit(int n) {
int count = 1;
while (true) {
int tmp = count * pow(10, count - 1) * 9;
if (n - tmp <= 0) break;
n -= tmp;
count++;
}
int n_tmp = pow(10, count - 1) + ceil(1.0 * n / count) - 1;
int n_mod = n % count == 0 ? count : n % count;
return (n_tmp / (int)pow(10, count - n_mod)) % 10;
}
};
int main(int argc, char const *argv[])
{
int tmp = pow(10, 3);
Solution so;
cout << so.findNthDigit(100) << endl;
return 0;
} | [
"wenshaoguo0611@gmail.com"
] | wenshaoguo0611@gmail.com |
ab2a12d19d33b3be12ea1be317850fa7312434db | 1bc942f396816a03a57e428356b5ae9ff6115508 | /Chapter 3. Data Structures/Maintaining Interval Data/Exercises Beginner/12299 - RMQ with Shifts.cpp | 090bf36de24ecbdfe367271e9b67d229ca0a2506 | [] | no_license | CookiC/UVaOJ | 17254be29224e8d1e034de22fa4ead2f61ccbbd9 | 1e852e8e7b498ca70e86a379315f2ec52d6435cd | refs/heads/master | 2021-01-10T18:11:54.246924 | 2017-05-21T23:43:57 | 2017-05-21T23:43:57 | 69,158,169 | 6 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,452 | cpp | //Author:CookiC
//#include"stdafx.h"
#include<iostream>
#include<cctype>
//#pragma warning(disable : 4996)
#define maxn 100010
#define maxlen 400010
#define INF 0x7FFFFFFF
using namespace std;
bool qIn(int &x){
char c;
while((c=getchar())!=EOF&&!isdigit(c));
if(c==EOF)
return false;
x=0;
do{
x*=10;
x+=c-'0';
}while((c=getchar())!=EOF&&isdigit(c));
return true;
}
bool qIn(char *p){
char c;
while((c=getchar())!=EOF&&(c==' '||c=='\n'));
if(c==EOF)
return false;
do{
*p++=c;
}while((c=getchar())!=EOF&&c!=' '&&c!='\n');
*p=0;
return true;
}
void qOut(int x){
char str[13];
if(x){
int i;
for(i=0;x;++i){
str[i]=x%10+'0';
x/=10;
}
while(i--)
putchar(str[i]);
}
else
putchar('0');
}
void qOut(char *p){
while(*p)
putchar(*p++);
}
struct TreeNode{
int min;
int L,R;
};
class SegmentTree{
private:
TreeNode tree[maxlen];
int *a,qL,qR,uX,uN;
void build(int o,int L,int R){
tree[o].L=L;
tree[o].R=R;
if(L==R){
tree[o].min=a[L];
return;
}
int M=L+(R-L)/2;
build(o*2,L,M);
build(o*2+1,M+1,R);
tree[o].min=min(tree[o*2].min,tree[o*2+1].min);
}
int query(int o){
int L=tree[o].L;
int R=tree[o].R;
if(qL<=L&&R<=qR)
return tree[o].min;
int ans=INF,M=L+(R-L)/2;
if(qL<=M) ans=min(ans,query(o*2));
if(M<qR) ans=min(ans,query(o*2+1));
return ans;
}
void update(int o){
int L=tree[o].L;
int R=tree[o].R;
if(L==R){
tree[o].min=uX;
return;
}
int M=L+(R-L)/2;
if(uN<=M) update(o*2);
else update(o*2+1);;
tree[o].min=min(tree[o*2].min,tree[o*2+1].min);
}
public:
void build(int *array,int len){
a=array;
build(1,1,len);
}
int query(int L,int R){
qL=L;
qR=R;
return query(1);
}
void update(int N,int X){
uX=X;
uN=N;
update(1);
}
};
SegmentTree Tree;
int n,q,i,j,k;
char *p;
char op[40];
int a[maxn],b[30];
void split(){
k=0;
while(*p){
int x=0;
while(isdigit(*p))
x=x*10+*p++-'0';
if(x)
b[k++]=x;
++p;
}
}
int main(){
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
ios::sync_with_stdio(false);
qIn(n);
qIn(q);
for(i=1;i<=n;++i)
qIn(a[i]);
Tree.build(a,n);
for(i=0;i<q;++i){
qIn(op);
p=op+5;
if(op[0]=='q'){
split();
qOut(Tree.query(b[0],b[1]));
putchar('\n');
}
else{
split();
int t=a[b[0]];
for(j=0;j<k-1;++j){
a[b[j]]=a[b[j+1]];
Tree.update(b[j],a[b[j]]);
}
a[b[k-1]]=t;
Tree.update(b[k-1],t);
}
}
return 0;
}
| [
"shen_yu_xiang@126.com"
] | shen_yu_xiang@126.com |
f70098b047bd151bb61502805605bff4271633d6 | b28305dab0be0e03765c62b97bcd7f49a4f8073d | /chrome/renderer/chrome_render_frame_observer.cc | 6c45e548f0e4edda8ca349291998a41606fcfefb | [
"BSD-3-Clause"
] | permissive | svarvel/browser-android-tabs | 9e5e27e0a6e302a12fe784ca06123e5ce090ced5 | bd198b4c7a1aca2f3e91f33005d881f42a8d0c3f | refs/heads/base-72.0.3626.105 | 2020-04-24T12:16:31.442851 | 2019-08-02T19:15:36 | 2019-08-02T19:15:36 | 171,950,555 | 1 | 2 | NOASSERTION | 2019-08-02T19:15:37 | 2019-02-21T21:47:44 | null | UTF-8 | C++ | false | false | 18,473 | cc | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/renderer/chrome_render_frame_observer.h"
#include <stddef.h>
#include <string.h>
#include <limits>
#include <string>
#include <utility>
#include <vector>
#include "base/command_line.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_isolated_world_ids.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/open_search_description_document_handler.mojom.h"
#include "chrome/common/prerender_messages.h"
#include "chrome/common/render_messages.h"
#include "chrome/renderer/prerender/prerender_helper.h"
#include "chrome/renderer/web_apps.h"
#include "components/crash/core/common/crash_key.h"
#include "components/offline_pages/buildflags/buildflags.h"
#include "components/translate/content/renderer/translate_helper.h"
#include "content/public/common/bindings_policy.h"
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_view.h"
#include "content/public/renderer/window_features_converter.h"
#include "extensions/common/constants.h"
#include "printing/buildflags/buildflags.h"
#include "services/service_manager/public/cpp/binder_registry.h"
#include "skia/ext/image_operations.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
#include "third_party/blink/public/platform/web_image.h"
#include "third_party/blink/public/platform/web_url_request.h"
#include "third_party/blink/public/web/web_document.h"
#include "third_party/blink/public/web/web_document_loader.h"
#include "third_party/blink/public/web/web_element.h"
#include "third_party/blink/public/web/web_frame_content_dumper.h"
#include "third_party/blink/public/web/web_local_frame.h"
#include "third_party/blink/public/web/web_node.h"
#include "third_party/blink/public/web/web_security_policy.h"
#include "third_party/blink/public/web/web_view.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/gfx/codec/jpeg_codec.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/geometry/size_f.h"
#include "url/gurl.h"
#if !defined(OS_ANDROID)
#include "chrome/renderer/searchbox/searchbox_extension.h"
#endif // !defined(OS_ANDROID)
#if defined(FULL_SAFE_BROWSING)
#include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
#endif
#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
#include "chrome/common/mhtml_page_notifier.mojom.h"
#endif
#if BUILDFLAG(ENABLE_PRINTING)
#include "components/printing/common/print_messages.h"
#include "components/printing/renderer/print_render_frame_helper.h"
#endif
using blink::WebDocumentLoader;
using blink::WebElement;
using blink::WebFrameContentDumper;
using blink::WebLocalFrame;
using blink::WebNode;
using blink::WebString;
using content::RenderFrame;
// Maximum number of characters in the document to index.
// Any text beyond this point will be clipped.
static const size_t kMaxIndexChars = 65535;
// Constants for UMA statistic collection.
static const char kTranslateCaptureText[] = "Translate.CaptureText";
// For a page that auto-refreshes, we still show the bubble, if
// the refresh delay is less than this value (in seconds).
static const double kLocationChangeIntervalInSeconds = 10;
// For the context menu, we want to keep transparency as is instead of
// replacing transparent pixels with black ones
static const bool kDiscardTransparencyForContextMenu = false;
namespace {
// If the source image is null or occupies less area than
// |thumbnail_min_area_pixels|, we return the image unmodified. Otherwise, we
// scale down the image so that the width and height do not exceed
// |thumbnail_max_size_pixels|, preserving the original aspect ratio.
SkBitmap Downscale(const SkBitmap& image,
int thumbnail_min_area_pixels,
const gfx::Size& thumbnail_max_size_pixels) {
if (image.isNull())
return SkBitmap();
gfx::Size image_size(image.width(), image.height());
if (image_size.GetArea() < thumbnail_min_area_pixels)
return image;
if (image_size.width() <= thumbnail_max_size_pixels.width() &&
image_size.height() <= thumbnail_max_size_pixels.height())
return image;
gfx::SizeF scaled_size = gfx::SizeF(image_size);
if (scaled_size.width() > thumbnail_max_size_pixels.width()) {
scaled_size.Scale(thumbnail_max_size_pixels.width() / scaled_size.width());
}
if (scaled_size.height() > thumbnail_max_size_pixels.height()) {
scaled_size.Scale(
thumbnail_max_size_pixels.height() / scaled_size.height());
}
return skia::ImageOperations::Resize(image,
skia::ImageOperations::RESIZE_GOOD,
static_cast<int>(scaled_size.width()),
static_cast<int>(scaled_size.height()));
}
} // namespace
ChromeRenderFrameObserver::ChromeRenderFrameObserver(
content::RenderFrame* render_frame)
: content::RenderFrameObserver(render_frame),
translate_helper_(nullptr),
phishing_classifier_(nullptr) {
render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
base::Bind(&ChromeRenderFrameObserver::OnRenderFrameObserverRequest,
base::Unretained(this)));
// Don't do anything else for subframes.
if (!render_frame->IsMainFrame())
return;
#if defined(SAFE_BROWSING_CSD)
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
if (!command_line.HasSwitch(switches::kDisableClientSidePhishingDetection))
SetClientSidePhishingDetection(true);
#endif
translate_helper_ = new translate::TranslateHelper(
render_frame, ISOLATED_WORLD_ID_TRANSLATE, extensions::kExtensionScheme);
}
ChromeRenderFrameObserver::~ChromeRenderFrameObserver() {
}
void ChromeRenderFrameObserver::OnInterfaceRequestForFrame(
const std::string& interface_name,
mojo::ScopedMessagePipeHandle* interface_pipe) {
registry_.TryBindInterface(interface_name, interface_pipe);
}
bool ChromeRenderFrameObserver::OnAssociatedInterfaceRequestForFrame(
const std::string& interface_name,
mojo::ScopedInterfaceEndpointHandle* handle) {
return associated_interfaces_.TryBindInterface(interface_name, handle);
}
bool ChromeRenderFrameObserver::OnMessageReceived(const IPC::Message& message) {
// Filter only.
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(ChromeRenderFrameObserver, message)
IPC_MESSAGE_HANDLER(PrerenderMsg_SetIsPrerendering, OnSetIsPrerendering)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
if (handled)
return false;
IPC_BEGIN_MESSAGE_MAP(ChromeRenderFrameObserver, message)
#if BUILDFLAG(ENABLE_PRINTING)
IPC_MESSAGE_HANDLER(PrintMsg_PrintNodeUnderContextMenu,
OnPrintNodeUnderContextMenu)
#endif
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void ChromeRenderFrameObserver::OnSetIsPrerendering(
prerender::PrerenderMode mode,
const std::string& histogram_prefix) {
if (mode != prerender::NO_PRERENDER) {
// If the PrerenderHelper for this frame already exists, don't create it. It
// can already be created for subframes during handling of
// RenderFrameCreated, if the parent frame was prerendering at time of
// subframe creation.
if (prerender::PrerenderHelper::Get(render_frame()))
return;
// The PrerenderHelper will destroy itself either after recording histograms
// or on destruction of the RenderView.
new prerender::PrerenderHelper(render_frame(), mode, histogram_prefix);
}
}
void ChromeRenderFrameObserver::RequestReloadImageForContextNode() {
WebLocalFrame* frame = render_frame()->GetWebFrame();
// TODO(dglazkov): This code is clearly in the wrong place. Need
// to investigate what it is doing and fix (http://crbug.com/606164).
WebNode context_node = frame->ContextMenuNode();
if (!context_node.IsNull() && context_node.IsElementNode()) {
frame->ReloadImage(context_node);
}
}
void ChromeRenderFrameObserver::RequestThumbnailForContextNode(
int32_t thumbnail_min_area_pixels,
const gfx::Size& thumbnail_max_size_pixels,
chrome::mojom::ImageFormat image_format,
RequestThumbnailForContextNodeCallback callback) {
WebNode context_node = render_frame()->GetWebFrame()->ContextMenuNode();
SkBitmap thumbnail;
gfx::Size original_size;
if (!context_node.IsNull() && context_node.IsElementNode()) {
SkBitmap image = context_node.To<WebElement>().ImageContents();
original_size = gfx::Size(image.width(), image.height());
thumbnail = Downscale(image,
thumbnail_min_area_pixels,
thumbnail_max_size_pixels);
}
SkBitmap bitmap;
if (thumbnail.colorType() == kN32_SkColorType) {
bitmap = thumbnail;
} else {
SkImageInfo info = thumbnail.info().makeColorType(kN32_SkColorType);
if (bitmap.tryAllocPixels(info)) {
thumbnail.readPixels(info, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
}
}
std::vector<uint8_t> thumbnail_data;
constexpr int kDefaultQuality = 90;
std::vector<unsigned char> data;
switch (image_format) {
case chrome::mojom::ImageFormat::PNG:
if (gfx::PNGCodec::EncodeBGRASkBitmap(
bitmap, kDiscardTransparencyForContextMenu, &data)) {
thumbnail_data.swap(data);
}
break;
case chrome::mojom::ImageFormat::JPEG:
if (gfx::JPEGCodec::Encode(bitmap, kDefaultQuality, &data))
thumbnail_data.swap(data);
break;
}
std::move(callback).Run(thumbnail_data, original_size);
}
void ChromeRenderFrameObserver::OnPrintNodeUnderContextMenu() {
#if BUILDFLAG(ENABLE_PRINTING)
printing::PrintRenderFrameHelper* helper =
printing::PrintRenderFrameHelper::Get(render_frame());
if (helper)
helper->PrintNode(render_frame()->GetWebFrame()->ContextMenuNode());
#endif
}
void ChromeRenderFrameObserver::GetWebApplicationInfo(
GetWebApplicationInfoCallback callback) {
WebLocalFrame* frame = render_frame()->GetWebFrame();
WebApplicationInfo web_app_info;
web_apps::ParseWebAppFromWebDocument(frame, &web_app_info);
// The warning below is specific to mobile but it doesn't hurt to show it even
// if the Chromium build is running on a desktop. It will get more exposition.
if (web_app_info.mobile_capable == WebApplicationInfo::MOBILE_CAPABLE_APPLE) {
blink::WebConsoleMessage message(
blink::WebConsoleMessage::kLevelWarning,
"<meta name=\"apple-mobile-web-app-capable\" content=\"yes\"> is "
"deprecated. Please include <meta name=\"mobile-web-app-capable\" "
"content=\"yes\"> - "
"http://developers.google.com/chrome/mobile/docs/installtohomescreen");
frame->AddMessageToConsole(message);
}
// Prune out any data URLs in the set of icons. The browser process expects
// any icon with a data URL to have originated from a favicon. We don't want
// to decode arbitrary data URLs in the browser process. See
// http://b/issue?id=1162972
for (auto it = web_app_info.icons.begin(); it != web_app_info.icons.end();) {
if (it->url.SchemeIs(url::kDataScheme))
it = web_app_info.icons.erase(it);
else
++it;
}
// Truncate the strings we send to the browser process.
web_app_info.title =
web_app_info.title.substr(0, chrome::kMaxMetaTagAttributeLength);
web_app_info.description =
web_app_info.description.substr(0, chrome::kMaxMetaTagAttributeLength);
std::move(callback).Run(web_app_info);
}
void ChromeRenderFrameObserver::SetClientSidePhishingDetection(
bool enable_phishing_detection) {
#if defined(SAFE_BROWSING_CSD)
phishing_classifier_ =
enable_phishing_detection
? safe_browsing::PhishingClassifierDelegate::Create(render_frame(),
nullptr)
: nullptr;
#endif
}
void ChromeRenderFrameObserver::ExecuteWebUIJavaScript(
const base::string16& javascript) {
#if !defined(OS_ANDROID)
webui_javascript_.push_back(javascript);
#endif
}
void ChromeRenderFrameObserver::DidFinishLoad() {
WebLocalFrame* frame = render_frame()->GetWebFrame();
// Don't do anything for subframes.
if (frame->Parent())
return;
GURL osdd_url = frame->GetDocument().OpenSearchDescriptionURL();
if (!osdd_url.is_empty()) {
chrome::mojom::OpenSearchDescriptionDocumentHandlerAssociatedPtr
osdd_handler;
render_frame()->GetRemoteAssociatedInterfaces()->GetInterface(
&osdd_handler);
osdd_handler->PageHasOpenSearchDescriptionDocument(
frame->GetDocument().Url(), osdd_url);
}
}
void ChromeRenderFrameObserver::DidCreateNewDocument() {
#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
DCHECK(render_frame());
if (!render_frame()->IsMainFrame())
return;
DCHECK(render_frame()->GetWebFrame());
blink::WebDocumentLoader* doc_loader =
render_frame()->GetWebFrame()->GetDocumentLoader();
DCHECK(doc_loader);
if (!doc_loader->IsArchive())
return;
// Connect to Mojo service on browser to notify it of the page's archive
// properties.
offline_pages::mojom::MhtmlPageNotifierAssociatedPtr mhtml_notifier;
render_frame()->GetRemoteAssociatedInterfaces()->GetInterface(
&mhtml_notifier);
DCHECK(mhtml_notifier);
blink::WebArchiveInfo info = doc_loader->GetArchiveInfo();
mhtml_notifier->NotifyIsMhtmlPage(info.url, info.date);
#endif
}
void ChromeRenderFrameObserver::DidStartProvisionalLoad(
WebDocumentLoader* document_loader,
bool is_content_initiated) {
// Let translate_helper do any preparatory work for loading a URL.
if (!translate_helper_)
return;
translate_helper_->PrepareForUrl(
render_frame()->GetWebFrame()->GetDocument().Url());
}
void ChromeRenderFrameObserver::DidCommitProvisionalLoad(
bool is_same_document_navigation,
ui::PageTransition transition) {
WebLocalFrame* frame = render_frame()->GetWebFrame();
// Don't do anything for subframes.
if (frame->Parent())
return;
static crash_reporter::CrashKeyString<8> view_count_key("view-count");
view_count_key.Set(
base::NumberToString(content::RenderView::GetRenderViewCount()));
#if !defined(OS_ANDROID)
if (render_frame()->GetEnabledBindings() &
content::kWebUIBindingsPolicyMask) {
for (const auto& script : webui_javascript_)
render_frame()->ExecuteJavaScript(script);
webui_javascript_.clear();
}
#endif
}
void ChromeRenderFrameObserver::DidClearWindowObject() {
#if !defined(OS_ANDROID)
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
if (command_line.HasSwitch(switches::kInstantProcess))
SearchBoxExtension::Install(render_frame()->GetWebFrame());
#endif // !defined(OS_ANDROID)
}
void ChromeRenderFrameObserver::CapturePageText(TextCaptureType capture_type) {
WebLocalFrame* frame = render_frame()->GetWebFrame();
if (!frame)
return;
// Don't capture pages that have pending redirect or location change.
if (frame->IsNavigationScheduledWithin(kLocationChangeIntervalInSeconds))
return;
// Don't index/capture pages that are in view source mode.
if (frame->IsViewSourceModeEnabled())
return;
// Don't capture text of the error pages.
WebDocumentLoader* document_loader = frame->GetDocumentLoader();
if (document_loader && document_loader->HasUnreachableURL())
return;
// Don't index/capture pages that are being prerendered.
if (prerender::PrerenderHelper::IsPrerendering(render_frame()))
return;
base::TimeTicks capture_begin_time = base::TimeTicks::Now();
// Retrieve the frame's full text (up to kMaxIndexChars), and pass it to the
// translate helper for language detection and possible translation.
// TODO(dglazkov): WebFrameContentDumper should only be used for
// testing purposes. See http://crbug.com/585164.
base::string16 contents =
WebFrameContentDumper::DeprecatedDumpFrameTreeAsText(frame,
kMaxIndexChars)
.Utf16();
UMA_HISTOGRAM_TIMES(kTranslateCaptureText,
base::TimeTicks::Now() - capture_begin_time);
// We should run language detection only once. Parsing finishes before
// the page loads, so let's pick that timing.
if (translate_helper_ && capture_type == PRELIMINARY_CAPTURE) {
translate_helper_->PageCaptured(contents);
}
TRACE_EVENT0("renderer", "ChromeRenderFrameObserver::CapturePageText");
#if defined(SAFE_BROWSING_CSD)
// Will swap out the string.
if (phishing_classifier_)
phishing_classifier_->PageCaptured(&contents,
capture_type == PRELIMINARY_CAPTURE);
#endif
}
void ChromeRenderFrameObserver::DidMeaningfulLayout(
blink::WebMeaningfulLayout layout_type) {
// Don't do any work for subframes.
if (!render_frame()->IsMainFrame())
return;
switch (layout_type) {
case blink::WebMeaningfulLayout::kFinishedParsing:
CapturePageText(PRELIMINARY_CAPTURE);
break;
case blink::WebMeaningfulLayout::kFinishedLoading:
CapturePageText(FINAL_CAPTURE);
break;
default:
break;
}
}
void ChromeRenderFrameObserver::OnDestruct() {
delete this;
}
void ChromeRenderFrameObserver::OnRenderFrameObserverRequest(
chrome::mojom::ChromeRenderFrameAssociatedRequest request) {
bindings_.AddBinding(this, std::move(request));
}
void ChromeRenderFrameObserver::SetWindowFeatures(
blink::mojom::WindowFeaturesPtr window_features) {
render_frame()->GetRenderView()->GetWebView()->SetWindowFeatures(
content::ConvertMojoWindowFeaturesToWebWindowFeatures(*window_features));
}
void ChromeRenderFrameObserver::UpdateBrowserControlsState(
content::BrowserControlsState constraints,
content::BrowserControlsState current,
bool animate) {
#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
render_frame()->GetRenderView()->UpdateBrowserControlsState(constraints,
current, animate);
#endif
}
| [
"artem@brave.com"
] | artem@brave.com |
5cee2b6bd7e22f256e2a096e727f785a2314f9d0 | 36b9decf14d266d6babaf1c44085c2ba869c03ce | /Remnant-main/Remnant/SDK/Weapon_Pan_EyeOfTheStorm_parameters.h | dd6e51aa453970a0bd2c9832a2168c8d0d30463f | [] | no_license | RoryGlenn/RemnantLootSwitcher | 6e309a7b2b7bac88a166b552b640c830b863eb2d | 85c4cb6839b7c0f60cf8143c571d64ca12439a63 | refs/heads/master | 2022-12-29T08:47:15.713546 | 2020-10-23T22:01:45 | 2020-10-23T22:01:45 | 305,910,400 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 941 | h | #pragma once
// Name: Remnant, Version: 6
#include "../SDK.h"
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
/*!!HELPER_DEF!!*/
/*!!DEFINE!!*/
namespace UFT
{
//---------------------------------------------------------------------------
// Parameters
//---------------------------------------------------------------------------
// Function Weapon_Pan_EyeOfTheStorm.Weapon_Pan_EyeOfTheStorm_C.OnActivated
struct AWeapon_Pan_EyeOfTheStorm_C_OnActivated_Params
{
};
// Function Weapon_Pan_EyeOfTheStorm.Weapon_Pan_EyeOfTheStorm_C.ExecuteUbergraph_Weapon_Pan_EyeOfTheStorm
struct AWeapon_Pan_EyeOfTheStorm_C_ExecuteUbergraph_Weapon_Pan_EyeOfTheStorm_Params
{
int EntryPoint; // (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"romglenn@ucsc.edu"
] | romglenn@ucsc.edu |
f16db36a703a845a2d51e1db7b1a8e82efe75160 | b83190692af1085b5693e239f7d852184b4b784e | /python/dartpy/dynamics/SimpleFrame.cpp | 51c1a617f4112ccdd0950bd1da504ea1117e3559 | [
"BSD-2-Clause"
] | permissive | balakumar-s/dart | 7242ad3ac2a6aa30a59dd6f4382b77ae52306c03 | 53907268b880f076a38815c075125af6960ffda8 | refs/heads/master | 2023-02-16T13:49:48.266987 | 2021-01-13T22:21:20 | 2021-01-13T22:21:20 | 113,634,201 | 0 | 0 | BSD-2-Clause | 2021-01-13T22:21:21 | 2017-12-09T02:05:26 | C++ | UTF-8 | C++ | false | false | 11,387 | cpp | /*
* Copyright (c) 2011-2019, The DART development contributors
* All rights reserved.
*
* The list of contributors can be found at:
* https://github.com/dartsim/dart/blob/master/LICENSE
*
* This file is provided under the following "BSD-style" License:
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* 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.
*/
#include <dart/dart.hpp>
#include <pybind11/pybind11.h>
#include "eigen_geometry_pybind.h"
#include "eigen_pybind.h"
namespace py = pybind11;
namespace dart {
namespace python {
void SimpleFrame(py::module& m)
{
::py::class_<
dart::dynamics::SimpleFrame,
dart::dynamics::ShapeFrame,
dart::dynamics::Detachable,
std::shared_ptr<dart::dynamics::SimpleFrame> >(m, "SimpleFrame")
.def(::py::init<>())
.def(::py::init<dart::dynamics::Frame*>(), ::py::arg("refFrame"))
.def(
::py::init<dart::dynamics::Frame*, const std::string&>(),
::py::arg("refFrame"),
::py::arg("name"))
.def(
::py::init<
dart::dynamics::Frame*,
const std::string&,
const Eigen::Isometry3d&>(),
::py::arg("refFrame"),
::py::arg("name"),
::py::arg("relativeTransform"))
.def(
"setName",
+[](dart::dynamics::SimpleFrame* self, const std::string& _name)
-> const std::string& { return self->setName(_name); },
::py::return_value_policy::reference_internal,
::py::arg("name"))
.def(
"getName",
+[](const dart::dynamics::SimpleFrame* self) -> const std::string& {
return self->getName();
},
::py::return_value_policy::reference_internal)
.def(
"clone",
+[](const dart::dynamics::SimpleFrame* self)
-> std::shared_ptr<dart::dynamics::SimpleFrame> {
return self->clone();
})
.def(
"clone",
+[](const dart::dynamics::SimpleFrame* self,
dart::dynamics::Frame* _refFrame)
-> std::shared_ptr<dart::dynamics::SimpleFrame> {
return self->clone(_refFrame);
},
::py::arg("refFrame"))
.def(
"copy",
+[](dart::dynamics::SimpleFrame* self,
const dart::dynamics::Frame* _otherFrame) {
self->copy(_otherFrame);
},
::py::arg("otherFrame"))
.def(
"copy",
+[](dart::dynamics::SimpleFrame* self,
const dart::dynamics::Frame* _otherFrame,
dart::dynamics::Frame* _refFrame) {
self->copy(_otherFrame, _refFrame);
},
::py::arg("otherFrame"),
::py::arg("refFrame"))
.def(
"copy",
+[](dart::dynamics::SimpleFrame* self,
const dart::dynamics::Frame* _otherFrame,
dart::dynamics::Frame* _refFrame,
bool _copyProperties) {
self->copy(_otherFrame, _refFrame, _copyProperties);
},
::py::arg("otherFrame"),
::py::arg("refFrame"),
::py::arg("copyProperties"))
.def(
"spawnChildSimpleFrame",
+[](dart::dynamics::SimpleFrame* self)
-> std::shared_ptr<dart::dynamics::SimpleFrame> {
return self->spawnChildSimpleFrame();
})
.def(
"spawnChildSimpleFrame",
+[](dart::dynamics::SimpleFrame* self, const std::string& name)
-> std::shared_ptr<dart::dynamics::SimpleFrame> {
return self->spawnChildSimpleFrame(name);
},
::py::arg("name"))
.def(
"spawnChildSimpleFrame",
+[](dart::dynamics::SimpleFrame* self,
const std::string& name,
const Eigen::Isometry3d& relativeTransform)
-> std::shared_ptr<dart::dynamics::SimpleFrame> {
return self->spawnChildSimpleFrame(name, relativeTransform);
},
::py::arg("name"),
::py::arg("relativeTransform"))
.def(
"setRelativeTransform",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Isometry3d& _newRelTransform) {
self->setRelativeTransform(_newRelTransform);
},
::py::arg("newRelTransform"))
.def(
"setRelativeTranslation",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _newTranslation) {
self->setRelativeTranslation(_newTranslation);
},
::py::arg("newTranslation"))
.def(
"setRelativeRotation",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Matrix3d& _newRotation) {
self->setRelativeRotation(_newRotation);
},
::py::arg("newRotation"))
.def(
"setTransform",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Isometry3d& _newTransform) {
self->setTransform(_newTransform);
},
::py::arg("newTransform"))
.def(
"setTransform",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Isometry3d& _newTransform,
const dart::dynamics::Frame* _withRespectTo) {
self->setTransform(_newTransform, _withRespectTo);
},
::py::arg("newTransform"),
::py::arg("withRespectTo"))
.def(
"setTranslation",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _newTranslation) {
self->setTranslation(_newTranslation);
},
::py::arg("newTranslation"))
.def(
"setTranslation",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _newTranslation,
const dart::dynamics::Frame* _withRespectTo) {
self->setTranslation(_newTranslation, _withRespectTo);
},
::py::arg("newTranslation"),
::py::arg("withRespectTo"))
.def(
"setRotation",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Matrix3d& _newRotation) {
self->setRotation(_newRotation);
},
::py::arg("newRotation"))
.def(
"setRotation",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Matrix3d& _newRotation,
const dart::dynamics::Frame* _withRespectTo) {
self->setRotation(_newRotation, _withRespectTo);
},
::py::arg("newRotation"),
::py::arg("withRespectTo"))
.def(
"setRelativeSpatialVelocity",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector6d& _newSpatialVelocity) {
self->setRelativeSpatialVelocity(_newSpatialVelocity);
},
::py::arg("newSpatialVelocity"))
.def(
"setRelativeSpatialVelocity",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector6d& _newSpatialVelocity,
const dart::dynamics::Frame* _inCoordinatesOf) {
self->setRelativeSpatialVelocity(
_newSpatialVelocity, _inCoordinatesOf);
},
::py::arg("newSpatialVelocity"),
::py::arg("inCoordinatesOf"))
.def(
"setRelativeSpatialAcceleration",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector6d& _newSpatialAcceleration) {
self->setRelativeSpatialAcceleration(_newSpatialAcceleration);
},
::py::arg("newSpatialAcceleration"))
.def(
"setRelativeSpatialAcceleration",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector6d& _newSpatialAcceleration,
const dart::dynamics::Frame* _inCoordinatesOf) {
self->setRelativeSpatialAcceleration(
_newSpatialAcceleration, _inCoordinatesOf);
},
::py::arg("newSpatialAcceleration"),
::py::arg("inCoordinatesOf"))
.def(
"setClassicDerivatives",
+[](dart::dynamics::SimpleFrame* self) {
self->setClassicDerivatives();
})
.def(
"setClassicDerivatives",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _linearVelocity) {
self->setClassicDerivatives(_linearVelocity);
},
::py::arg("linearVelocity"))
.def(
"setClassicDerivatives",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _linearVelocity,
const Eigen::Vector3d& _angularVelocity) {
self->setClassicDerivatives(_linearVelocity, _angularVelocity);
},
::py::arg("linearVelocity"),
::py::arg("angularVelocity"))
.def(
"setClassicDerivatives",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _linearVelocity,
const Eigen::Vector3d& _angularVelocity,
const Eigen::Vector3d& _linearAcceleration) {
self->setClassicDerivatives(
_linearVelocity, _angularVelocity, _linearAcceleration);
},
::py::arg("linearVelocity"),
::py::arg("angularVelocity"),
::py::arg("linearAcceleration"))
.def(
"setClassicDerivatives",
+[](dart::dynamics::SimpleFrame* self,
const Eigen::Vector3d& _linearVelocity,
const Eigen::Vector3d& _angularVelocity,
const Eigen::Vector3d& _linearAcceleration,
const Eigen::Vector3d& _angularAcceleration) {
self->setClassicDerivatives(
_linearVelocity,
_angularVelocity,
_linearAcceleration,
_angularAcceleration);
},
::py::arg("linearVelocity"),
::py::arg("angularVelocity"),
::py::arg("linearAcceleration"),
::py::arg("angularAcceleration"));
}
} // namespace python
} // namespace dart
| [
"noreply@github.com"
] | noreply@github.com |
0fa761b37eced1bb210dd471d7ba40702fa9260c | f1cc3dd5613ee443d236be1639f8e137abd56c10 | /app/src/main/cpp/util/BlockQueue.h | d21edc109b0beb9c61fa161c9de66891776423ac | [] | no_license | yetote/MyPlayer | ab838899f066442211dad318b5eab162817f2534 | 540debf769cb419a2acfc2d4160ddaa025eeada9 | refs/heads/master | 2020-04-28T16:01:18.645865 | 2019-06-26T07:51:29 | 2019-06-26T07:51:29 | 175,396,099 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 700 | h | //
// Created by ether on 2019/3/14.
//
#ifndef MYPLAYER_BLOCKQUEUE_H
#define MYPLAYER_BLOCKQUEUE_H
#include "Log.h"
#include "PlayerStatus.h"
#include <queue>
#include <mutex>
#define BlockQueue_TAG "BlockQueue"
extern "C" {
#include <libavcodec/avcodec.h>
}
class BlockQueue {
public:
void push(AVPacket *packet);
void init();
bool pop(AVPacket *packet1, bool isFinish);
void clear();
void setMaxSize(int size);
BlockQueue(int maxSize);
virtual ~BlockQueue();
std::queue<AVPacket *> queue;
private:
AVPacket *packet;
std::condition_variable cond;
std::mutex mutex;
int maxSize = 0;
void stop();
};
#endif //MYPLAYER_BLOCKQUEUE_H
| [
"503779938@qq.com"
] | 503779938@qq.com |
0e0ea2cb0e883317dd85132e4e98dc5f1d43d1b3 | 53fc674a9c64871e2dcc592345ba0392a6962294 | /RaspberryPi/robot.h | 4be8ad6b28ae877fe6a1dba92663dc30542c5e5e | [] | no_license | tfox12/RoboticsLab | 707728fe4221222ebf4beb60b44a89bdc88f7e6b | 7d287570be5290aa8bbd6ccc304a75457d311c93 | refs/heads/master | 2021-01-13T02:30:12.572280 | 2013-01-14T10:21:04 | 2013-01-14T10:21:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 301 | h | #ifndef _ROBOT_H_
#define _ROBOT_H_
#include "motor.h"
#include "sensor.h"
#include <string>
namespace RaspberryPi
{
class Robot
{
public:
Robot();
protected:
Motor motors[8];
Sensor digital[12];
Sensor analog[8];
};
}
#endif
| [
"tim@ubuntu.(none)"
] | tim@ubuntu.(none) |
5c97f69da0cf6050d121f8b35d7d832ed2feb10c | 5e94dfb56c2723024e2fcba3f7d963ecd68ee78e | /MyActor/actor/scattered.h | 2731328098a5f1f74769abc01dd7005598569344 | [] | no_license | askskype/CPP-Actor-framework | b49e584828feb08aec49d53111e750e14bbbb2ed | d4fe4413e88f1badb3fc66186ec9fc3578aa12e6 | refs/heads/master | 2020-12-29T00:01:37.774690 | 2015-11-16T11:24:56 | 2015-11-16T11:24:56 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 5,898 | h | #ifndef __SCATTERED_H
#define __SCATTERED_H
#include <algorithm>
#include <functional>
#include <memory>
#include <list>
#include "try_move.h"
using namespace std;
#define NAME_BOND(__NAMEL__, __NAMER__) __NAMEL__ ## __NAMER__
#ifdef _MSC_VER
#ifdef _WIN64
#pragma comment(lib, NAME_BOND(__FILE__, "./../asm_lib_x64.lib"))
#else
#pragma comment(lib, NAME_BOND(__FILE__, "./../asm_lib_x86.lib"))
#endif // _WIN64
#endif
#ifdef _MSC_VER
#define FRIEND_SHARED_PTR(__T__)\
friend std::shared_ptr<__T__>;\
friend std::_Ref_count<__T__>;
#elif __GNUG__
#define FRIEND_SHARED_PTR(__T__)\
friend std::shared_ptr<__T__>; \
friend std::__shared_count<__gnu_cxx::__default_lock_policy>;\
friend std::_Sp_counted_ptr<__T__*, __gnu_cxx::__default_lock_policy>;
#endif
template <typename CL>
struct out_of_scope
{
template <typename TC>
out_of_scope(TC&& cl)
:_cl(TRY_MOVE(cl)) {}
~out_of_scope()
{
_cl();
}
CL _cl;
private:
out_of_scope(const out_of_scope&){};
void operator =(const out_of_scope&){}
};
#define BOND_LINE(__P__, __L__) NAME_BOND(__P__, __L__)
//作用域退出时自动调用lambda
#define OUT_OF_SCOPE(__CL__) \
auto BOND_LINE(__t, __LINE__) = [&]__CL__; \
out_of_scope<decltype(BOND_LINE(__t, __LINE__))> BOND_LINE(__cl, __LINE__)(BOND_LINE(__t, __LINE__))
#if (_DEBUG || DEBUG)
#define DEBUG_OPERATION(__exp__) __exp__
#else
#define DEBUG_OPERATION(__exp__)
#endif
#if (_DEBUG || DEBUG)
#define CHECK_EXCEPTION(__h) try { (__h)(); } catch (...) { assert(false); }
#define CHECK_EXCEPTION1(__h, __p0) try { (__h)(__p0); } catch (...) { assert(false); }
#define CHECK_EXCEPTION2(__h, __p0, __p1) try { (__h)(__p0, __p1); } catch (...) { assert(false); }
#define CHECK_EXCEPTION3(__h, __p0, __p1, __p2) try { (__h)(__p0, __p1, __p2); } catch (...) { assert(false); }
#define BEGIN_CHECK_EXCEPTION try {
#define END_CHECK_EXCEPTION } catch (...) { assert(false); }
#else
#define CHECK_EXCEPTION(__h) (__h)()
#define CHECK_EXCEPTION1(__h, __p0) (__h)(__p0)
#define CHECK_EXCEPTION2(__h, __p0, __p1) (__h)(__p0, __p1)
#define CHECK_EXCEPTION3(__h, __p0, __p1, __p2) (__h)(__p0, __p1, __p2)
#define BEGIN_CHECK_EXCEPTION
#define END_CHECK_EXCEPTION
#endif
//内存边界对齐
#define MEM_ALIGN(__o, __a) (((__o) + ((__a)-1)) & (((__a)-1) ^ -1))
//////////////////////////////////////////////////////////////////////////
#define BEGIN_TRY_ {\
bool __catched = false; \
try {
#define CATCH_FOR(__exp__) }\
catch (__exp__&) { __catched = true; }\
DEBUG_OPERATION(catch (...) { assert(false); })\
if (__catched) {
#define END_TRY_ }}
#define RUN_IN_STRAND(__host__, __strand__, __exp__) __host__->send(__strand__, [&] {__exp__;})
#define begin_RUN_IN_STRAND(__host__, __strand__) __host__->send(__strand__, [&] {
#define end_RUN_IN_STRAND() })
#define begin_ACTOR_RUN_IN_STRAND(__host__, __strand__) {\
my_actor* ___host = __host__; \
actor_handle ___actor = my_actor::create(__strand__, [&](my_actor* __host__) {
#define end_ACTOR_RUN_IN_STRAND() });\
___actor->notify_run(); \
___host->actor_wait_quit(___actor); \
}
#define RUN_IN_TRHEAD_STACK(__host__, __exp__) {\
my_actor::quit_guard qg(__host__); \
__host__->run_in_thread_stack([&] {__exp__; });}
#define begin_RUN_IN_TRHEAD_STACK(__host__){\
my_actor::quit_guard qg(__host__); \
__host__->run_in_thread_stack([&] {
#define end_RUN_IN_TRHEAD_STACK() });}
/*!
@brief 这个类在测试消息传递时使用
*/
struct move_test
{
struct count
{
int _id;
size_t _copyCount;
size_t _moveCount;
std::function<void(std::shared_ptr<count>)> _cb;
};
explicit move_test(int id);
move_test();
~move_test();
move_test(int id, const std::function<void(std::shared_ptr<count>)>& cb);
move_test(const move_test& s);
move_test(move_test&& s);
void operator=(const move_test& s);
void operator=(move_test&& s);
friend std::ostream& operator <<(std::ostream& out, const move_test& s);
std::shared_ptr<count> _count;
size_t _generation;
};
/*!
@brief 启用高精度时钟
*/
void enable_high_resolution();
std::string get_time_string_us();
std::string get_time_string_ms();
std::string get_time_string_s();
std::string get_time_string_s_file();
long long get_tick_us();
long long get_tick_ms();
int get_tick_s();
#ifdef _MSC_VER
void* get_sp();
extern "C" void __fastcall get_bp_sp_ip(void** pbp, void** psp, void** pip);
extern "C" unsigned long long __fastcall cpu_tick();
#elif __GNUG__
void get_bp_sp_ip(void** pbp, void** psp, void** pip);
void* get_sp();
unsigned long long cpu_tick();
#endif
#ifdef CHECK_ACTOR_STACK
struct stack_line_info
{
stack_line_info(){}
stack_line_info(stack_line_info&& s)
:line(s.line),
file(std::move(s.file)),
module(std::move(s.module)),
symbolName(std::move(s.symbolName)) {}
int line;
std::string file;
std::string module;
std::string symbolName;
};
//记录当前Actor入口信息
#define ACTOR_POSITION(__host__) \
{\
__host__->_checkStackFree = true; \
stack_line_info __line; \
__line.line = __LINE__; \
__line.file = __FILE__; \
__line.module = "actor position"; \
__host__->_createStack->push_front(__line); \
}
//记录当前Actor入口信息
#define SELF_POSITION ACTOR_POSITION(self)
/*!
@brief 获取当前调用堆栈信息
@param maxDepth 获取当前堆栈向下最高层次，最大32层
*/
list<stack_line_info> get_stack_list(size_t maxDepth = 32, size_t offset = 0, bool module = false, bool symbolName = false);
/*!
@brief 堆栈溢出弹出消息
*/
void stack_overflow_format(int size, std::shared_ptr<list<stack_line_info>> createStack);
#else //CHECK_ACTOR_STACK
//记录当前Actor入口信息
#define ACTOR_POSITION(__host__)
#define SELF_POSITION
#endif //CHECK_ACTOR_STACK
/*!
@brief 清空std::function
*/
template <typename F>
inline void clear_function(F& f)
{
f = F();
}
#ifdef _MSC_VER
#define snPrintf sprintf_s
#elif __GNUG__
#define snPrintf snprintf
#endif
#endif | [
"591170887@qq.com"
] | 591170887@qq.com |
172aab6a7d9957df1f3714cdb52f89b0383b2548 | 9d131f72a2bf28c6ceecc222c5fbfa48b4a6da48 | /source/datastorage.cpp | 35e3b71bb79dc6d13b10358561241f955e29db0e | [] | no_license | hacklab-turku/hackjam_roottori | 7ba48d9705ae05804b364d42c8411c3dec6fee62 | c873f45ee4ec12bef439ee2133a3a251a9bf80d5 | refs/heads/master | 2020-12-25T19:26:04.046635 | 2013-08-17T11:27:16 | 2013-08-17T11:27:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,444 | cpp | #include "datastorage.hpp"
#include <algorithm>
#include <iostream>
DataStorage::DataStorage()
{
}
/**
* Loads the data that is required by the game for
* displaying the game before it officially starts
* This includes loading screens, loading music
* and similar
* Returns 0 if successful
*/
int DataStorage::loadInitialData()
{
loadTextureAndStoreSprite("logo", "data/2D/engine_logo.png");
loadSound("biisi", "data/audio/biisi.ogg");
return 0;
}
/**
* Load all the game's content
* Returns 0 if successful
*/
int DataStorage::loadAllData()
{
return 0;
}
/**
* Loads a new texture from the given path and stores the produced Texture in the textureContainer as a shared_ptr
* The texture is stored based on the given name
* Returns -1 if error, 0 if success
*/
int DataStorage::loadTexture(std::string name, std::string path)
{
std::shared_ptr<sf::Texture> texture = std::shared_ptr<sf::Texture>(new sf::Texture());
if (!texture->loadFromFile(path))
{
std::cout << "!DataStorage: Error loading file " << path << std::endl;
return -1;
}
textureContainer[name] = texture;
std::cout << "+DataStorage: Successfully loaded " << path << " as " << name << std::endl;
return 0;
}
/**
* Loads a new texture from the given path and stores the produced Texture in the textureContainer as a shared_ptr
* Also creates a new sprite with the original dimensions from this texture
* Returns -1 if error, 0 if success
*/
int DataStorage::loadTextureAndStoreSprite(std::string name, std::string path)
{
TexturePtr texture(new sf::Texture());
if (!texture->loadFromFile(path))
{
std::cout << "!DataStorage: Error loading file: " << path << std::endl;
return -1;
}
textureContainer[name] = texture;
SpritePtr sp(new sf::Sprite(*texture));
storeSprite(name, sp);
std::cout << "+DataStorage: Successfully loaded " << path << " as " << name << std::endl;
return 0;
}
/**
* Stores an existing sprite into the spriteContainer
*/
int DataStorage::storeSprite(std::string name, std::shared_ptr<sf::Sprite> s)
{
spriteContainer[name] = s;
return 0;
}
/**
* Creates a new texture and then returns a shared_ptr to it
* params:
* name: The name that will be given to the created sprite. Also stored in spriteContainer by this name
* textureName: The texture that will be used for this, searched from textureContainer
* sizeX, sizeY: The area of the rectangle that will be used out of the texture. You might want to use 100x100 of a 256x256 texture
* coordX, coordY: The offset in the texture. You may want to take a 100x100 region out of 256x256 texture, but not from top left corner
* Returns a pointer to the newly created texture, or nullptr if failed
*/
SpritePtr DataStorage::createAndGiveSprite(std::string name, std::string textureName, int sizeX, int sizeY, int coordX, int coordY)
{
sf::IntRect subRect;
subRect.left = coordX;
subRect.top = coordY;
subRect.width = sizeX;
subRect.height = sizeY;
TexturePtr texturePointer = getTexture(textureName);
if (texturePointer == nullptr)
{
std::cout << "DataStorage: Cannot create texture. Desired texture not found in memory: " << textureName << std::endl;
return nullptr;
}
SpritePtr sprite(new sf::Sprite((*texturePointer), subRect));
storeSprite(name, sprite);
return sprite;
}
/**
* Loads a new sound by filename. Also creates a soundbuffer object and stores it
* Returns -1 if failure
*
* Does not support mp3. ogg is preferred over other formats
*/
int DataStorage::loadSound(std::string name, std::string path)
{
SoundBufferPtr buffer(new sf::SoundBuffer());
if (!(*buffer).loadFromFile(path))
{
std::cout << "!DataStorage: Error loading audio file " << path << std::endl;
return -1;
}
soundBufferContainer[name] = buffer;
std::shared_ptr<sf::Sound> sound = std::shared_ptr<sf::Sound>(new sf::Sound());
sound->setBuffer((*buffer));
soundContainer[name] = sound;
std::cout << "+DataStorage: Successfully loaded " << path << "as " << name << std::endl;
return 0;
}
/**
* Returns a shared_ptr<sf::Sprite> to a loaded sprite
* or nullptr if not found
*/
SpritePtr DataStorage::getSprite(std::string name)
{
std::map<std::string, SpritePtr>::iterator iter;
iter = spriteContainer.find(name);
if (iter == spriteContainer.end())
{
std::cout << "!DataStorage: Can't find requested sprite in map: " << name << std::endl;
return nullptr;
}
return iter->second;
}
/**
* Returns a shared_ptr<sf::Texture> to a loaded texture
* or nullptr if not found
*/
TexturePtr DataStorage::getTexture(std::string name)
{
std::map<std::string, TexturePtr>::iterator iter;
iter = textureContainer.find(name);
if (iter == textureContainer.end())
{
std::cout << "!DataStorage: Can't find requested texture in map: " << name << std::endl;
return nullptr;
}
return iter->second;
}
/**
* Returns a shared_ptr<sf::Sound> to a loaded sound
* or nullptr if not found
*/
SoundPtr DataStorage::getSound(std::string name)
{
std::map<std::string, SoundPtr>::iterator iter;
iter = soundContainer.find(name);
if (iter == soundContainer.end())
{
std::cout << "!DataStorage: Can't find requested soundfile in map: " << name << std::endl;
return nullptr;
}
return iter->second;
}
| [
"jesse.kaukonen@gmail.com"
] | jesse.kaukonen@gmail.com |
103a6bbec56aa5ad3c50e40ff3376259b3cbe63d | f94da7ec05e92e1a8593908143606e545b64c339 | /Visual Studio 2013/projects/Lecture7-LinkedList/Lecture7-DoublyLinked/List.cpp | 0ec65621fdc9c160adfa5923445c5b69cff46e1b | [] | no_license | jonhassall/AdvancedSoftwareEngineeringSOFT40051 | 4eaafa655335878fb108c56ec0d59ef11b9481e8 | 968c2df2aa670193313c1b157a4da6dadff15334 | refs/heads/master | 2016-09-03T06:50:46.398250 | 2014-12-01T21:44:13 | 2014-12-01T21:44:13 | 26,221,759 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,155 | cpp | // Version: V1.0
// Date: 23-11-14
// Name: Jonathan Hassall
#include <iostream>
#include "List.h"
#include "Link.h"
using namespace std;
List::List()
{
// 'head' points to 0 initially and when the list is empty.
// Otherwise 'head' points to most recently
// added object head
head = NULL;
tail = NULL;
}
List::~List()
{
List::clear();
}
void List::display()
{
cout << "Display forward...\n";
Link* temp; // 'temp' used to iterate through the list
// 'head' points to last object added
// Iterate back through list until last pointer (which is 0)
for (temp = head; temp != NULL; temp = temp->next)
{
cout << "Value of object is " << temp->x << endl;
}
}
void List::displayBackward()
{
cout << "Display backward...\n";
Link* temp; // 'temp' used to iterate through the list
// Same as display, but in reverse
// Still efficient, thanks to the prev pointers
cout << tail->x;
for (temp = tail; temp != NULL; temp = temp->prev)
{
cout << "Value of object is " << temp->x << endl;
}
}
//Return the value of the top of the stack
int List::top()
{
if (!isEmpty())
{
return head->x;
}
else
{
return false;
}
}
//Remove top item from stack and return it
int List::pop()
{
//Check if empty
if (isEmpty())
{
return 0;
}
Link* temp;
Link* current;
int tempX;
tempX = head->x;
temp = head; // Point to one to remove
head = head->next; // Point head second object
head->prev = NULL;
delete temp; // Free the memory
// Again delete must come after temp has been used (to provide the next link).
return tempX;
}
//Get size of stack
int List::size()
{
int counter = 0;
if (isEmpty())
{
return counter;
}
Link* temp; // 'temp' used to iterate through the list
// 'head' points to last object added
// Iterate back through list until last pointer (which is 0)
for (temp = head; temp != 0; temp = temp->next)
{
counter++;
}
return counter;
}
//Returns true if stack is empty
bool List::isEmpty()
{
if (head == NULL)
{
return true;
}
else
{
return false;
}
}
int List::removeByValue(int value)
{
Link* temp;
Link* current;
if (List::isEmpty() == true)
//if (head == 0) // check for empty list
//Nothing to do
{
return 0;
}
// Same as inside loop in clear function
if (head->x == value) // check first object
{ // Remove 1st element
cout << "Removing first element...\n";
//Works OK
temp = head; // Point to one to remove
head = head->next; // Point head second object
head->prev = NULL;
if (size() == 1)
{
tail = head;
}
delete temp; // Free the memory
// Again delete must come after temp has been used (to provide the next link).
return 1;
}
// Check the rest of the list
for (current = head; current->next != NULL; current = current->next)
{
cout << ".";
if (current->next->x == value)
{
// Remove the object AFTER the one to which current points
temp = current->next;
current->next = temp->next;
cout << "Flag2\n";
Link* temp2;
temp2 = temp->next;
temp2->prev = current;
delete temp; // Free the memory
return 1;
}
}
return 0; // Return value indicates whether successful
}
int List::clear() //Clear all objects from the list
{
cout << "Clearing list.\n";
Link* temp;
while (head != NULL)
{
//Remove first element
temp = head;
head = head->next;
delete temp;
}
tail = NULL;
return 1;
}
//Push an entry onto the start of the stack
int List::push(int x)
{
// Pointer 'temp' used to instantiate objects to add to list
Link* temp;
// Memory allocated and the object is given a value
temp = new Link(x);
if (temp == NULL) // check new succeeded
{
return 0; // shows error in memory allocation
}
if (head == NULL)
{
//If list is empty
head = temp;
tail = temp;
temp->prev = NULL;
temp->next = NULL;
}
else
{
head->prev = temp;
temp->next = head;
temp->prev = NULL;
head = temp;
}
} | [
"jon@jonhassall.com"
] | jon@jonhassall.com |
1d2722f194f63a3d648772281a9982481c2bda87 | 56faa945655349a2c529b5076139ad823db2e516 | /leetcode/medium/457.cpp | 6899c14c96c36038bab6d991e496e55f45abf72e | [] | no_license | lijinpei/leetcode | 61e3fec4ec935ec0d3a8048e5df6c022b3663545 | 9833469506f4802009398b6217e510e35b188c95 | refs/heads/master | 2018-10-17T08:28:08.716683 | 2018-08-02T16:30:50 | 2018-08-02T16:30:50 | 120,696,376 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,134 | cpp | #include <iostream>
#include <vector>
class Solution {
public:
bool circularArrayLoop(std::vector<int> &nums) {
int n = nums.size();
bool direction;
for (int i = 0; i < n; ++i) {
if (!nums[i]) {
continue;
}
direction = nums[i] > 0;
int m = i;
int ln = 0;
while (true) {
int mv = nums[m];
if (mv == 0 || direction ^(mv > 0)) {
break;
}
int m1 = m + nums[m];
while (m1 < 0) {
m1 += n;
}
while (m1 >= n) {
m1 -= n;
}
if (m == m1) {
break;
} else {
++ln;
if (ln >= n) {
return true;
}
}
m = m1;
}
// not a loop, now mark them zero
int m1 = i;
while (m1 != m) {
int m2 = m1 + nums[m1];
nums[m1] = 0;
while (m2 < 0) {
m2 += n;
}
while (m2 >= n) {
m2 -= n;
}
m1 = m2;
}
}
return false;
}
};
int main() {
Solution sol;
std::vector<int> input{-1, 2};
sol.circularArrayLoop(input);
}
| [
"leekingp1994@163.com"
] | leekingp1994@163.com |
dfd75133f16515578dcff34dc1832c735e532cd9 | d00d604cbdea1d459a0b15a564d921d58b5f4276 | /DnD/src/tools/Point.h | 16fa5d6522a130b45abf888000ab25346b3dea48 | [] | no_license | Iscandel/DnD | bc1fee8fe485dd1ca94ddd1c99a41a28f696a86d | 82810a45ba3ba1b13ebbdd3de9961423e4a7719f | refs/heads/master | 2020-06-23T17:44:33.079494 | 2019-07-25T00:21:08 | 2019-07-25T00:21:08 | 198,702,771 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,903 | h | #ifndef H__POINT_091020130108__H
#define H__POINT_091020130108__H
///////////////////////////////////////////////////////////////////////////////
/// Utility class for 2D position
///////////////////////////////////////////////////////////////////////////////
template<class T>
struct Point
{
///////////////////////////////////////////////////////////////////////////////
/// Constructor
/// \param x: x position
/// \param y: y position
///////////////////////////////////////////////////////////////////////////////
Point(T x = 0, T y = 0)
:x(x)
,y(y)
{
}
T x; ///< x coordinate
T y; ///< y coordinate
};
///////////////////////////////////////////////////////////////////////////////
/// Compares 2 points. The 2 coordinates must be equal.
///////////////////////////////////////////////////////////////////////////////
inline bool operator == (const Point<int>& c1, const Point<int>& c2)
{
return c1.x == c2.x && c1.y == c2.y;
}
///////////////////////////////////////////////////////////////////////////////
/// Compares 2 points. The 2 coordinates must be equal.
///////////////////////////////////////////////////////////////////////////////
inline bool operator != (const Point<int>& c1, const Point<int>& c2)
{
return !(c1 == c2);
}
///////////////////////////////////////////////////////////////////////////////
/// Adds 2 points
///////////////////////////////////////////////////////////////////////////////
template<class T>
inline Point<T> operator + (const Point<T>& c1, const Point<T>& c2)
{
Point<T> res;
res.x = c1.x + c2.x;
res.y = c1.y + c2.y;
return res;
}
///////////////////////////////////////////////////////////////////////////////
/// Adds 2 points
///////////////////////////////////////////////////////////////////////////////
template<class T>
inline Point<T>& operator += (Point<T>& c1, const Point<T>& c2)
{
c1 = c1 + c2;
return c1;
};
///////////////////////////////////////////////////////////////////////////////
/// Subtracts 2 points
///////////////////////////////////////////////////////////////////////////////
template<class T>
inline Point<T> operator - (const Point<T>& c1, const Point<T>& c2)
{
Point<T> res;
res.x = c1.x - c2.x;
res.y = c1.y - c2.y;
return res;
}
///////////////////////////////////////////////////////////////////////////////
/// Subtracts 2 points
///////////////////////////////////////////////////////////////////////////////
template<class T>
inline Point<T>& operator -= (Point<T>& c1, const Point<T>& c2)
{
c1 = c1 - c2;
return c1;
}
///////////////////////////////////////////////////////////////////////////////
/// point times scalar
///////////////////////////////////////////////////////////////////////////////
template<class T, class U>
inline Point<T> operator * (const Point<T>& c1, U scalar)
{
Point<T> res;
res.x = c1.x * scalar;
res.y = c1.y * scalar;
return res;
}
#endif | [
"Moi@moi"
] | Moi@moi |
c74c7731530b7f4f58f89b2ff0598100516dd6f3 | 9f2439040c4219dea2282718d5044ff0b1093fea | /Exp9/Exp9_Graph/test.cpp | 7e2747e14379d36aeb12de7da57dd5057e816438 | [] | no_license | LHQQ/Data-structure-experiments-of-Hefei-University-of-Technology | 44815b4a8b09b09794a547d9952902371ceeba21 | 5f1acf04f2eba5ec14d4355c5422dcfe6ec46fcb | refs/heads/master | 2020-06-04T12:15:14.524674 | 2019-01-11T08:06:40 | 2019-01-11T08:06:40 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 8,659 | cpp | #include "pch.h"
#include "graph.cpp"
//#define DEBUG
#ifdef DEBUG
int deBug1(void);
#else
int menu(const char *str, graph &G);
int c_graph(char str[64], graph &G);
int menu_c_graph(void);
#endif // DEBUG
int main()
{
char ch;
char str[64];
graph G;
#ifdef DEBUG
std::cin >> ch;
deBug1();
#else
menu(str, G);
std::cin >> ch;
while (ch != '0')
{
system("CLS");
switch (ch)
{
case 'a':
c_graph(str, G);
break;
case 'b':
G.delete_G();
std::cout << "The graph has been destroyed." << std::endl;
break;
case '1':
if (!G.empty())
{
std::cout << str << std::endl;
G.dfsTraversal_l();
G.bfsTraversal_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '2':
if (!G.empty())
{
std::cout << str << std::endl;
std::cout << "该图中边(弧)的数量为:" << G.get_Enum_l() << std::endl;
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '3':
if (!G.empty())
{
std::cout << str << std::endl;
G.dfsTraversal_t_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '4':
if (!G.empty())
{
std::cout << str << std::endl;
G.bfsTraversal_t_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '5':
if (!G.empty())
{
std::cout << str << std::endl;
G.Prim_l(G.getNode_for_ID(0));
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '6':
if (!G.empty())
{
std::cout << str << std::endl;
G.Kruskal_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '7':
if (!G.empty())
{
std::cout << str << std::endl;
G.Dijkstra_l(G.getNode_for_ID(0));
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '8':
if (!G.empty())
{
std::cout << str << std::endl;
G.Floyd_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case '9':
if (!G.empty())
{
std::cout << str << std::endl;
G.AOV_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
case 'e':
if (!G.empty())
{
std::cout << str << std::endl;
G.AOE_l();
}
else
{
std::cout << "Graph not created." << std::endl;
}
break;
default:
break;
}
std::cout << "Press any key to return." << std::endl;
std::cin >> ch;
system("CLS");
menu(str, G);
std::cin >> ch;
}
#endif // DEBUG
return 0;
}
#ifdef DEBUG
int deBug1(void)
{
char ch;
char str[64];
strcpy_s(str, "grpData\\udg115.grp");
graph G1(str);
std::cout << str << std::endl;
G1.dfsTraversal_l();
G1.bfsTraversal_l();
std::cout << "Graph Enum:" << G1.get_Enum_l() << std::endl;
G1.Prim_l(G1.getNode_for_data('a'));
G1.Prim_l(G1.getNode_for_data('h'));
G1.Prim_l(G1.getNode_for_data('k'));
G1.Kruskal_l();
strcpy_s(str, "grpData\\dg6.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.Prim_l(G1.getNode_for_data('e'));
G1.Kruskal_l();
strcpy_s(str, "grpData\\udn6.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.Prim_l(G1.getNode_for_data('1'));
G1.Kruskal_l();
G1.Dijkstra_l(G1.getNode_for_data('1'));
G1.Floyd_l();
strcpy_s(str, "grpData\\un8.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.Prim_l(G1.getNode_for_data('A'));
G1.Kruskal_l();
G1.Dijkstra_l(G1.getNode_for_data('A'));
G1.Floyd_l();
strcpy_s(str, "grpData\\dn8.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.Dijkstra_l(G1.getNode_for_data('1'));
G1.Floyd_l();
G1.AOV_l();
G1.AOE_l();
strcpy_s(str, "grpData\\dn10.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.Dijkstra_l(G1.getNode_for_data('a'));
G1.Floyd_l();
G1.AOV_l();
G1.AOE_l();
strcpy_s(str, "grpData\\top6dg1.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.AOV_l();
G1.AOE_l();
strcpy_s(str, "grpData\\top7dg1.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.AOV_l();
G1.AOE_l();
strcpy_s(str, "grpData\\kPath91.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.AOV_l();
G1.AOE_l();
strcpy_s(str, "grpData\\kPath101.grp");
G1.coverGraph(str);
std::cout << str << std::endl;
G1.AOV_l();
G1.AOE_l();
std::cin >> ch;
return 0;
}
#else
int menu(const char * str, graph & G)
{
if(!G.empty())
{
std::cout << str << std::endl;
}
else
{
std::cout << "Graph not created." << std::endl;
}
std::cout << "Please select the operation by input the very character." << std::endl;
std::cout << "0 for quiting." << std::endl;
std::cout << "a for creating or modifying graph.Attention, the original graph will be overwritten!" << std::endl;
std::cout << "b for destroying the graph." << std::endl;
std::cout << "1 for Exp1, traversing the graph." << std::endl;
std::cout << "2 for Exp2, counting the number of edges in the graph." << std::endl;
std::cout << "3 for Exp3, depth-first traversal of the spanning tree on the current graph." << std::endl;
std::cout << "4 for Exp4, breadth-first traversal of the spanning tree on the current graph." << std::endl;
std::cout << "5 for Exp5, executing the Prim algorithm on the current graph." << std::endl;
std::cout << "6 for Exp6, executing the Kruskal algorithm on the current graph." << std::endl;
std::cout << "7 for Exp7, executing the Dijkstra algorithm on the current graph." << std::endl;
std::cout << "8 for Exp8, executing the Floyd algorithm on the current graph." << std::endl;
std::cout << "9 for Exp9, performing a topological sort on the current graph." << std::endl;
std::cout << "e for Exp10, finding a critical path on the current graph." << std::endl;
return 0;
}
int c_graph(char str[64], graph & G)
{
char ch;
menu_c_graph();
std::cin >> ch;
switch (ch)
{
case '1':
strcpy(str, "grpData\\dg6.grp");
break;
case '2':
strcpy(str, "grpData\\dg8.grp");
break;
case '3':
strcpy(str, "grpData\\dn8.grp");
break;
case '4':
strcpy(str, "grpData\\dn10.grp");
break;
case '5':
strcpy(str, "grpData\\dn61.grp");
break;
case '6':
strcpy(str, "grpData\\f14.grp");
break;
case '7':
strcpy(str, "grpData\\kPath91.grp");
break;
case '8':
strcpy(str, "grpData\\kPath101.grp");
break;
case '9':
strcpy(str, "grpData\\Top6dg1.grp");
break;
case 'a':
strcpy(str, "grpData\\Top7dg1.grp");
break;
case 'b':
strcpy(str, "grpData\\udg4.grp");
break;
case 'c':
strcpy(str, "grpData\\udg8.grp");
break;
case 'd':
strcpy(str, "grpData\\udg10.grp");
break;
case 'e':
strcpy(str, "grpData\\udg114.grp");
break;
case 'f':
strcpy(str, "grpData\\udg115.grp");
break;
case 'g':
strcpy(str, "grpData\\udn6.grp");
break;
case 'h':
strcpy(str, "grpData\\udTree11.grp");
break;
case 'i':
strcpy(str, "grpData\\un8.grp");
break;
default:
break;
}
if (ch > '0' && ch <= '9')
{
std::cout << "Creating." << str << std::endl;
G.coverGraph(str);
std::cout << "Has been created!" << std::endl;
}
else if (ch >= 'a' && ch <= 'j')
{
std::cout << "Creating." << str << std::endl;
G.coverGraph(str);
std::cout << "Has been created!" << std::endl;
}
return 0;
}
int menu_c_graph(void)
{
std::cout << "Please select the graph you want to create:" << std::endl;
std::cout << "Other:quit!" << std::endl;
std::cout << "1 for dg6.grp" << std::endl;
std::cout << "2 for dg8.grp" << std::endl;
std::cout << "3 for dn8.grp" << std::endl;
std::cout << "4 for dn10.grp" << std::endl;
std::cout << "5 for dn61.grp" << std::endl;
std::cout << "6 for f14.grp" << std::endl;
std::cout << "7 for kPath91.grp" << std::endl;
std::cout << "8 for kPath101.grp" << std::endl;
std::cout << "9 for Top6dg1.grp" << std::endl;
std::cout << "a for Top7dg1.grp" << std::endl;
std::cout << "b for udg4.grp" << std::endl;
std::cout << "c for udg8.grp" << std::endl;
std::cout << "d for udg10.grp" << std::endl;
std::cout << "e for udg114.grp" << std::endl;
std::cout << "f for udg115.grp" << std::endl;
std::cout << "g for udn6.grp" << std::endl;
std::cout << "h for udTree11.grp" << std::endl;
std::cout << "i for un8.grp" << std::endl;
return 0;
}
#endif // DEBUG
| [
"u25th_engineer"
] | u25th_engineer |
d79676336bdb7e7da863a315baa4de4877befa06 | 8e5fe2174bc693409d14278374bddf42356103b7 | /IPdstAna/IConsts.hh | b4905a1d8bff78d74d6652917a875abfac7107fb | [] | no_license | iyounus/PHENIX_data_analysis_framework | 882b6689bb048f82145bccb6068ca76774dd568b | 0947c02ac09eb5be593c77a9baa73bd12ebffe64 | refs/heads/master | 2021-01-19T10:29:49.499214 | 2015-09-18T17:52:51 | 2015-09-18T17:52:51 | 42,703,530 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,393 | hh |
#ifndef ICONSTS_HH
#define ICONSTS_HH
#define EPS 1.0e-20
#define PI 3.14159265358979323846
#define TwoPI 6.28318530717958647692
#define PIby2 1.57079632679489661923
#define SqrtTwoPI 2.50662827463100050241
class IConsts
{
public:
IConsts(int run);
~IConsts();
static int RUN;
static int NPtTBins; // number of trigger particle pt bins
static int NPtABins; // number of associated particle pt bins
static double* PtT; // trigger particle pt bins
static double* PtA; // associated particle pt bins
static double MinPhi;
static double MaxPhi;
static double MinDPhi;
static double MaxDPhi;
static double MinDPhiN; // min value of near side dphi histogram
static double MaxDPhiN; // max value of near side dphi histogram
static double MinDPhiF; // min value of away side dphi histogram
static double MaxDPhiF; // max value of away side dphi histogram
static double MinTheta;
static double MaxTheta;
static double EMCB1; // min phi for EMCal
static double EMCB2; // max phi for EMCal
static double DCHB1; // min phi for DCH
static double DCHB2; // max phi for DCH
static double NSigN; // no. of sigmas for near side dphi histo limits
static double NSigF; // no. of sigmas for away side dphi histo limits
static double* SigN; // sigma for near side peak
static double* SigF; // sigma for away side peak
static double EAsym;
static double Pi0Width; // sigma for pi0 mass width
static double ConeAngle; // angle of cone arong a particle
static double MatchSig; // PC3 & EMC matching sigma
static short TrChar; // track charge. if 0 both + and - are included
static short EMCArm; // +1 for west, -1 for east, 0 for both arms
static double BbcChLo; // BBC charge lo limit
static double BbcChHi; // BBC charge hi limit
static short BbcNLo; // BBC multiplicity lo limit
static short BbcNHi; // BBC multiplicity hi limit
static short AsymConfig; // asymmetry configuration:
// 0 -> physics asym, (++,--)-(+-,-+)
// 1 -> parity violating, (++)-(--)
// 2 -> parity violating, (+-)-(-+)
// 3 -> parity violating, (B+)-(B-)
// 4 -> parity violating, (Y+)-(Y-)
static short H[10][4]; // helicity combinations. see implementation
static char* RunList; // txt file with list of runs to be processed
static char* InDir; // directory with input pdst files
static char* OutDir; // directory for any output files
static char* OutFile; // output file name if any
static char* SpinFile; // root file contining spin information
static char* PbScStats; // root file with pi0 mass/widths for PbSc
static char* PbGlStats; // root file with pi0 mass/widths for PbGl
static char* EMCWarnMap; // warn/dead map file for EMCal
static char* FillTable; // fill lookup take for runs
static char* FilePrefix; // prefix for pdst file name: IPdstReco_
static bool Defined; // IConsts is instantiated if true
//void Read(const char* txt_file);
static void Print();
void SetRunList (char* list);
void SetInDir (char* dir );
void SetOutDir (char* dir );
void SetOutFile (char* file);
void SetSpinFile (char* spin);
void SetPbScStats (char* pbsc);
void SetPbGlStats (char* pbsc);
void SetEMCWarnMap(char* map );
void SetFillTable (char* fill);
void SetFilePrefix(char* pre );
void SetTriggerPtBins(int nbins, double *ptt);
void SetAssociatedPtBins(int nbins, double *pta);
void SetAsymConfig(short a){AsymConfig = a;}
void SetTrCharge(short ch){TrChar = ch;}
void SetEMCalArm(short arm){EMCArm = arm;}
void SetBBCchar(double lo, double hi){BbcChLo = lo; BbcChHi = hi;}
void SetBBCmult(short lo, short hi){BbcNLo = lo; BbcNHi = hi;}
void SetPhiAcceptanceT(double lo, double hi)
{EMCB1 = lo*PI/180.; EMCB2 = hi*PI/180.;}
void SetPhiAcceptanceA(double lo, double hi)
{DCHB1 = lo*PI/180.; DCHB2 = hi*PI/180.;}
void SetPi0Width(double Nsigma){Pi0Width = Nsigma;}
void SetPC3EMCmatch(double sig){MatchSig = sig;}
void SetConeAngle(double angle){ConeAngle = angle;}
};
#endif
| [
"imranyounus@gmail.com"
] | imranyounus@gmail.com |
dc7c94ef0caeb446057a7e7a58a17178fb31691c | e4811f3907453ecd25f0ca03ca9c78e8b0cac96c | /CPP/7zip/Archive/Chm/ChmIn.h | 60852852dc81f102b9b23a1ae4335972b6b0d01b | [] | no_license | keithjjones/7z | 9ddff9b524851be04452fdd72e761f0a26e216d2 | 174a5af5960d2bbebc7deb3b7bc622f5f62b9a3e | refs/heads/master | 2021-01-10T08:48:04.232649 | 2016-03-17T20:28:37 | 2016-03-17T20:28:37 | 48,259,207 | 5 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 5,965 | h | // Archive/ChmIn.h
#ifndef __ARCHIVE_CHM_IN_H
#define __ARCHIVE_CHM_IN_H
#include "../../../Common/MyBuffer.h"
#include "../../../Common/MyString.h"
#include "../../IStream.h"
#include "../../Common/InBuffer.h"
namespace NArchive {
namespace NChm {
struct CItem
{
UInt64 Section;
UInt64 Offset;
UInt64 Size;
AString Name;
bool IsFormatRelatedItem() const
{
if (Name.Len() < 2)
return false;
return Name[0] == ':' && Name[1] == ':';
}
bool IsUserItem() const
{
if (Name.Len() < 2)
return false;
return Name[0] == '/';
}
bool IsDir() const
{
if (Name.IsEmpty())
return false;
return (Name.Back() == '/');
}
};
struct CDatabase
{
UInt64 StartPosition;
UInt64 ContentOffset;
CObjectVector<CItem> Items;
AString NewFormatString;
bool Help2Format;
bool NewFormat;
UInt64 PhySize;
void UpdatePhySize(UInt64 v) { if (PhySize < v) PhySize = v; }
int FindItem(const AString &name) const
{
FOR_VECTOR (i, Items)
if (Items[i].Name == name)
return i;
return -1;
}
void Clear()
{
NewFormat = false;
NewFormatString.Empty();
Help2Format = false;
Items.Clear();
StartPosition = 0;
PhySize = 0;
}
};
const UInt32 kBlockSize = 1 << 15;
struct CResetTable
{
UInt64 UncompressedSize;
UInt64 CompressedSize;
// unsigned BlockSizeBits;
CRecordVector<UInt64> ResetOffsets;
bool GetCompressedSizeOfBlocks(UInt64 blockIndex, UInt32 numBlocks, UInt64 &size) const
{
if (blockIndex >= ResetOffsets.Size())
return false;
UInt64 startPos = ResetOffsets[(unsigned)blockIndex];
if (blockIndex + numBlocks >= ResetOffsets.Size())
size = CompressedSize - startPos;
else
size = ResetOffsets[(unsigned)(blockIndex + numBlocks)] - startPos;
return true;
}
bool GetCompressedSizeOfBlock(UInt64 blockIndex, UInt64 &size) const
{
return GetCompressedSizeOfBlocks(blockIndex, 1, size);
}
UInt64 GetNumBlocks(UInt64 size) const
{
return (size + kBlockSize - 1) / kBlockSize;
}
};
struct CLzxInfo
{
UInt32 Version;
unsigned ResetIntervalBits;
unsigned WindowSizeBits;
UInt32 CacheSize;
CResetTable ResetTable;
unsigned GetNumDictBits() const
{
if (Version == 2 || Version == 3)
return 15 + WindowSizeBits;
return 0;
}
UInt64 GetFolderSize() const { return kBlockSize << ResetIntervalBits; }
UInt64 GetFolder(UInt64 offset) const { return offset / GetFolderSize(); }
UInt64 GetFolderPos(UInt64 folderIndex) const { return folderIndex * GetFolderSize(); }
UInt64 GetBlockIndexFromFolderIndex(UInt64 folderIndex) const { return folderIndex << ResetIntervalBits; }
bool GetOffsetOfFolder(UInt64 folderIndex, UInt64 &offset) const
{
UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
if (blockIndex >= ResetTable.ResetOffsets.Size())
return false;
offset = ResetTable.ResetOffsets[(unsigned)blockIndex];
return true;
}
bool GetCompressedSizeOfFolder(UInt64 folderIndex, UInt64 &size) const
{
UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
return ResetTable.GetCompressedSizeOfBlocks(blockIndex, (UInt32)1 << ResetIntervalBits, size);
}
};
struct CMethodInfo
{
GUID Guid;
CByteBuffer ControlData;
CLzxInfo LzxInfo;
bool IsLzx() const;
bool IsDes() const;
AString GetGuidString() const;
UString GetName() const;
};
struct CSectionInfo
{
UInt64 Offset;
UInt64 CompressedSize;
UInt64 UncompressedSize;
AString Name;
CObjectVector<CMethodInfo> Methods;
bool IsLzx() const;
UString GetMethodName() const;
};
class CFilesDatabase: public CDatabase
{
public:
bool LowLevel;
CUIntVector Indices;
CObjectVector<CSectionInfo> Sections;
UInt64 GetFileSize(unsigned fileIndex) const { return Items[Indices[fileIndex]].Size; }
UInt64 GetFileOffset(unsigned fileIndex) const { return Items[Indices[fileIndex]].Offset; }
UInt64 GetFolder(unsigned fileIndex) const
{
const CItem &item = Items[Indices[fileIndex]];
const CSectionInfo §ion = Sections[(unsigned)item.Section];
if (section.IsLzx())
return section.Methods[0].LzxInfo.GetFolder(item.Offset);
return 0;
}
UInt64 GetLastFolder(unsigned fileIndex) const
{
const CItem &item = Items[Indices[fileIndex]];
const CSectionInfo §ion = Sections[(unsigned)item.Section];
if (section.IsLzx())
return section.Methods[0].LzxInfo.GetFolder(item.Offset + item.Size - 1);
return 0;
}
void HighLevelClear()
{
LowLevel = true;
Indices.Clear();
Sections.Clear();
}
void Clear()
{
CDatabase::Clear();
HighLevelClear();
}
void SetIndices();
void Sort();
bool Check();
};
class CInArchive
{
CMyComPtr<ISequentialInStream> m_InStreamRef;
::CInBuffer _inBuffer;
UInt64 _chunkSize;
bool _help2;
Byte ReadByte();
void ReadBytes(Byte *data, UInt32 size);
void Skip(size_t size);
UInt16 ReadUInt16();
UInt32 ReadUInt32();
UInt64 ReadUInt64();
UInt64 ReadEncInt();
void ReadString(unsigned size, AString &s);
void ReadUString(unsigned size, UString &s);
void ReadGUID(GUID &g);
HRESULT ReadChunk(IInStream *inStream, UInt64 pos, UInt64 size);
HRESULT ReadDirEntry(CDatabase &database);
HRESULT DecompressStream(IInStream *inStream, const CDatabase &database, const AString &name);
public:
bool IsArc;
bool HeadersError;
bool UnexpectedEnd;
bool UnsupportedFeature;
CInArchive(bool help2) { _help2 = help2; }
HRESULT OpenChm(IInStream *inStream, CDatabase &database);
HRESULT OpenHelp2(IInStream *inStream, CDatabase &database);
HRESULT OpenHighLevel(IInStream *inStream, CFilesDatabase &database);
HRESULT Open2(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
};
}}
#endif
| [
"keith@keithjjones.com"
] | keith@keithjjones.com |
890051c92e14503a7e64c39f3987ba9cec38c859 | e7d0656f1705c19d18763c7be1d23fe0dace2e50 | /ext/Clock.cpp | 64f9a0909f869fd890ac45bedbff3bdee3581687 | [] | no_license | paulas/sfml-ruby | c3805cebb9e47579077020ebf9e3ccbb907204e2 | 00c7dbfc669bfe8bb7fa7ebc17ca2769d82b443f | refs/heads/master | 2020-12-03T09:11:44.772639 | 2014-12-19T14:23:10 | 2014-12-19T14:23:10 | 39,339,126 | 1 | 0 | null | 2015-07-19T15:46:53 | 2015-07-19T15:46:53 | null | UTF-8 | C++ | false | false | 947 | cpp | /*
* Clock.cpp
*
* Created on: 28.06.2013
* Author: hanmac
*/
#include "Clock.hpp"
#define _self unwrap<sf::Clock*>(self)
VALUE rb_cSFMLClock;
macro_template2(sf::Clock,NULL,rb_cSFMLClock)
namespace RubySFML {
namespace Clock {
macro_alloc(sf::Clock)
singlereturn(getElapsedTime)
singlereturn(restart)
VALUE _measure(VALUE self)
{
sf::Clock cl;
rb_yield(Qnil);
return wrap(cl.getElapsedTime());
}
}
}
void Init_SFMLClock(VALUE rb_mSFML)
{
using namespace RubySFML::Clock;
#if 0
rb_mSFML = rb_define_module("SFML");
#endif
rb_cSFMLClock = rb_define_class_under(rb_mSFML,"Clock",rb_cObject);
rb_define_alloc_func(rb_cSFMLClock,_alloc);
rb_undef_method(rb_cSFMLClock,"_load");
rb_define_method(rb_cSFMLClock,"time",RUBY_METHOD_FUNC(_getElapsedTime),0);
rb_define_method(rb_cSFMLClock,"restart",RUBY_METHOD_FUNC(_restart),0);
rb_define_singleton_method(rb_cSFMLClock,"measure",RUBY_METHOD_FUNC(_measure),0);
}
| [
"hanmac@gmx.de"
] | hanmac@gmx.de |
7497f686b3115337b80a8c7e41c90ccc05949c76 | a211018ab583b57984407a430329a691314b766c | /src/renderer/atlas/BackendD2D.cpp | f9e14275117766d10cdb0f854f8e7ebd015e4798 | [
"BSD-3-Clause",
"MIT",
"Unlicense",
"BSD-2-Clause",
"LGPL-2.1-or-later",
"LicenseRef-scancode-object-form-exception-to-mit"
] | permissive | rzak23/terminal | 6b6341ab7da5e190a6bc25dab4758a4ac3495c67 | 1da6131cb2b6fe783b8c65864b89334c501493a5 | refs/heads/master | 2023-05-12T20:06:48.167951 | 2023-05-01T15:20:23 | 2023-05-01T15:20:23 | 266,528,969 | 0 | 0 | MIT | 2020-05-24T11:42:54 | 2020-05-24T11:42:54 | null | UTF-8 | C++ | false | false | 26,778 | cpp | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
#include "pch.h"
#include "BackendD2D.h"
#if ATLAS_DEBUG_SHOW_DIRTY
#include "colorbrewer.h"
#endif
#if ATLAS_DEBUG_DUMP_RENDER_TARGET
#include "wic.h"
#endif
TIL_FAST_MATH_BEGIN
// Disable a bunch of warnings which get in the way of writing performant code.
#pragma warning(disable : 26429) // Symbol 'data' is never tested for nullness, it can be marked as not_null (f.23).
#pragma warning(disable : 26446) // Prefer to use gsl::at() instead of unchecked subscript operator (bounds.4).
#pragma warning(disable : 26459) // You called an STL function '...' with a raw pointer parameter at position '...' that may be unsafe [...].
#pragma warning(disable : 26481) // Don't use pointer arithmetic. Use span instead (bounds.1).
#pragma warning(disable : 26482) // Only index into arrays using constant expressions (bounds.2).
using namespace Microsoft::Console::Render::Atlas;
void BackendD2D::ReleaseResources() noexcept
{
_renderTarget.reset();
_renderTarget4.reset();
// Ensure _handleSettingsUpdate() is called so that _renderTarget gets recreated.
_generation = {};
}
void BackendD2D::Render(RenderingPayload& p)
{
if (_generation != p.s.generation())
{
_handleSettingsUpdate(p);
}
_renderTarget->BeginDraw();
#if ATLAS_DEBUG_SHOW_DIRTY || ATLAS_DEBUG_DUMP_RENDER_TARGET
// Invalidating the render target helps with spotting Present1() bugs.
_renderTarget->Clear();
#endif
_drawBackground(p);
_drawCursorPart1(p);
_drawText(p);
_drawCursorPart2(p);
_drawSelection(p);
#if ATLAS_DEBUG_SHOW_DIRTY
_debugShowDirty(p);
#endif
THROW_IF_FAILED(_renderTarget->EndDraw());
#if ATLAS_DEBUG_DUMP_RENDER_TARGET
_debugDumpRenderTarget(p);
#endif
}
bool BackendD2D::RequiresContinuousRedraw() noexcept
{
return false;
}
void BackendD2D::_handleSettingsUpdate(const RenderingPayload& p)
{
const auto renderTargetChanged = !_renderTarget;
const auto fontChanged = _fontGeneration != p.s->font.generation();
const auto cursorChanged = _cursorGeneration != p.s->cursor.generation();
const auto cellCountChanged = _cellCount != p.s->cellCount;
if (renderTargetChanged)
{
{
wil::com_ptr<ID3D11Texture2D> buffer;
THROW_IF_FAILED(p.swapChain.swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(buffer.addressof())));
const D2D1_RENDER_TARGET_PROPERTIES props{
.type = D2D1_RENDER_TARGET_TYPE_DEFAULT,
.pixelFormat = { DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED },
.dpiX = static_cast<f32>(p.s->font->dpi),
.dpiY = static_cast<f32>(p.s->font->dpi),
};
// ID2D1RenderTarget and ID2D1DeviceContext are the same and I'm tired of pretending they're not.
THROW_IF_FAILED(p.d2dFactory->CreateDxgiSurfaceRenderTarget(buffer.query<IDXGISurface>().get(), &props, reinterpret_cast<ID2D1RenderTarget**>(_renderTarget.addressof())));
_renderTarget.query_to(_renderTarget4.addressof());
_renderTarget->SetUnitMode(D2D1_UNIT_MODE_PIXELS);
_renderTarget->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
}
{
static constexpr D2D1_COLOR_F color{};
THROW_IF_FAILED(_renderTarget->CreateSolidColorBrush(&color, nullptr, _emojiBrush.put()));
THROW_IF_FAILED(_renderTarget->CreateSolidColorBrush(&color, nullptr, _brush.put()));
_brushColor = 0;
}
}
if (!_dottedStrokeStyle)
{
static constexpr D2D1_STROKE_STYLE_PROPERTIES props{ .dashStyle = D2D1_DASH_STYLE_CUSTOM };
static constexpr FLOAT dashes[2]{ 1, 1 };
THROW_IF_FAILED(p.d2dFactory->CreateStrokeStyle(&props, &dashes[0], 2, _dottedStrokeStyle.addressof()));
}
if (renderTargetChanged || fontChanged)
{
const auto dpi = static_cast<f32>(p.s->font->dpi);
_renderTarget->SetDpi(dpi, dpi);
_renderTarget->SetTextAntialiasMode(static_cast<D2D1_TEXT_ANTIALIAS_MODE>(p.s->font->antialiasingMode));
}
if (renderTargetChanged || fontChanged || cellCountChanged)
{
const D2D1_BITMAP_PROPERTIES props{
.pixelFormat = { DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED },
.dpiX = static_cast<f32>(p.s->font->dpi),
.dpiY = static_cast<f32>(p.s->font->dpi),
};
const D2D1_SIZE_U size{
p.s->cellCount.x,
p.s->cellCount.y,
};
const D2D1_MATRIX_3X2_F transform{
.m11 = static_cast<f32>(p.s->font->cellSize.x),
.m22 = static_cast<f32>(p.s->font->cellSize.y),
};
THROW_IF_FAILED(_renderTarget->CreateBitmap(size, nullptr, 0, &props, _backgroundBitmap.put()));
THROW_IF_FAILED(_renderTarget->CreateBitmapBrush(_backgroundBitmap.get(), _backgroundBrush.put()));
_backgroundBrush->SetInterpolationMode(D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
_backgroundBrush->SetExtendModeX(D2D1_EXTEND_MODE_MIRROR);
_backgroundBrush->SetExtendModeY(D2D1_EXTEND_MODE_MIRROR);
_backgroundBrush->SetTransform(&transform);
_backgroundBitmapGeneration = {};
}
if (fontChanged || cursorChanged)
{
_cursorBitmap.reset();
_cursorBitmapSize = {};
}
_generation = p.s.generation();
_fontGeneration = p.s->font.generation();
_cursorGeneration = p.s->cursor.generation();
_cellCount = p.s->cellCount;
}
void BackendD2D::_drawBackground(const RenderingPayload& p) noexcept
{
if (_backgroundBitmapGeneration != p.colorBitmapGenerations[0])
{
_backgroundBitmap->CopyFromMemory(nullptr, p.backgroundBitmap.data(), gsl::narrow_cast<UINT32>(p.colorBitmapRowStride * sizeof(u32)));
_backgroundBitmapGeneration = p.colorBitmapGenerations[0];
}
// If the terminal was 120x30 cells and 1200x600 pixels large, this would draw the
// background by upscaling a 120x30 pixel bitmap to fill the entire render target.
const D2D1_RECT_F rect{ 0, 0, static_cast<f32>(p.s->targetSize.x), static_cast<f32>(p.s->targetSize.y) };
_renderTarget->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_COPY);
_renderTarget->FillRectangle(&rect, _backgroundBrush.get());
_renderTarget->SetPrimitiveBlend(D2D1_PRIMITIVE_BLEND_SOURCE_OVER);
}
void BackendD2D::_drawText(RenderingPayload& p)
{
til::CoordType dirtyTop = til::CoordTypeMax;
til::CoordType dirtyBottom = til::CoordTypeMin;
// It is possible to create a "_foregroundBrush" similar to how the `_backgroundBrush` is created and
// use that as the brush for text rendering below. That way we wouldn't have to search `row->colors` for color
// changes and could draw entire lines of text in a single call. Unfortunately Direct2D is not particularly
// smart if you do this and chooses to draw the given text into a way too small offscreen texture first and
// then blends it on the screen with the given bitmap brush. While this roughly doubles the performance
// when drawing lots of colors, the extra latency drops performance by >10x when drawing fewer colors.
// Since fewer colors are more common, I've chosen to go with regular solid-color brushes.
u16 y = 0;
for (const auto row : p.rows)
{
auto baselineX = 0.0f;
auto baselineY = static_cast<f32>(p.s->font->cellSize.y * y + p.s->font->baseline);
if (row->lineRendition != LineRendition::SingleWidth)
{
baselineY = _drawTextPrepareLineRendition(p, row, baselineY);
}
for (const auto& m : row->mappings)
{
const auto colorsBegin = row->colors.begin();
auto it = colorsBegin + m.glyphsFrom;
const auto end = colorsBegin + m.glyphsTo;
while (it != end)
{
const auto beg = it;
const auto off = it - colorsBegin;
const auto fg = *it;
while (++it != end && *it == fg)
{
}
const auto count = it - beg;
const auto brush = _brushWithColor(fg);
const DWRITE_GLYPH_RUN glyphRun{
.fontFace = m.fontFace.get(),
.fontEmSize = p.s->font->fontSize,
.glyphCount = gsl::narrow_cast<UINT32>(count),
.glyphIndices = &row->glyphIndices[off],
.glyphAdvances = &row->glyphAdvances[off],
.glyphOffsets = &row->glyphOffsets[off],
};
const D2D1_POINT_2F baselineOrigin{
baselineX,
baselineY,
};
if (glyphRun.fontFace)
{
D2D1_RECT_F bounds = GlyphRunEmptyBounds;
if (const auto enumerator = TranslateColorGlyphRun(p.dwriteFactory4.get(), baselineOrigin, &glyphRun))
{
while (ColorGlyphRunMoveNext(enumerator.get()))
{
const auto colorGlyphRun = ColorGlyphRunGetCurrentRun(enumerator.get());
ColorGlyphRunDraw(_renderTarget4.get(), _emojiBrush.get(), brush, colorGlyphRun);
ColorGlyphRunAccumulateBounds(_renderTarget.get(), colorGlyphRun, bounds);
}
}
else
{
_renderTarget->DrawGlyphRun(baselineOrigin, &glyphRun, brush, DWRITE_MEASURING_MODE_NATURAL);
GlyphRunAccumulateBounds(_renderTarget.get(), baselineOrigin, &glyphRun, bounds);
}
if (bounds.top < bounds.bottom)
{
// Since we used SetUnitMode(D2D1_UNIT_MODE_PIXELS), bounds.top/bottom is in pixels already and requires no conversion/rounding.
if (row->lineRendition != LineRendition::DoubleHeightTop)
{
row->dirtyBottom = std::max(row->dirtyBottom, static_cast<i32>(lrintf(bounds.bottom)));
}
if (row->lineRendition != LineRendition::DoubleHeightBottom)
{
row->dirtyTop = std::min(row->dirtyTop, static_cast<i32>(lrintf(bounds.top)));
}
}
}
for (UINT32 i = 0; i < glyphRun.glyphCount; ++i)
{
baselineX += glyphRun.glyphAdvances[i];
}
}
}
if (!row->gridLineRanges.empty())
{
_drawGridlineRow(p, row, y);
}
if (row->lineRendition != LineRendition::SingleWidth)
{
_drawTextResetLineRendition(row);
}
if (p.invalidatedRows.contains(y))
{
dirtyTop = std::min(dirtyTop, row->dirtyTop);
dirtyBottom = std::max(dirtyBottom, row->dirtyBottom);
}
++y;
}
if (dirtyTop < dirtyBottom)
{
p.dirtyRectInPx.top = std::min(p.dirtyRectInPx.top, dirtyTop);
p.dirtyRectInPx.bottom = std::max(p.dirtyRectInPx.bottom, dirtyBottom);
}
}
f32 BackendD2D::_drawTextPrepareLineRendition(const RenderingPayload& p, const ShapedRow* row, f32 baselineY) const noexcept
{
const auto lineRendition = row->lineRendition;
D2D1_MATRIX_3X2_F transform{
.m11 = 2.0f,
.m22 = 1.0f,
};
if (lineRendition >= LineRendition::DoubleHeightTop)
{
D2D1_RECT_F clipRect{ 0, 0, static_cast<f32>(p.s->targetSize.x), static_cast<f32>(p.s->targetSize.y) };
transform.m22 = 2.0f;
transform.dy = -1.0f * (baselineY + p.s->font->descender);
// If you print the top half of a double height row (DECDHL), the expectation is that only
// the top half is visible, which requires us to keep the clip rect at the bottom of the row.
// (Vice versa for the bottom half of a double height row.)
if (lineRendition == LineRendition::DoubleHeightTop)
{
const auto delta = static_cast<f32>(p.s->font->cellSize.y);
baselineY += delta;
transform.dy -= delta;
clipRect.bottom = static_cast<f32>(row->dirtyBottom);
}
else
{
clipRect.top = static_cast<f32>(row->dirtyTop);
}
_renderTarget->PushAxisAlignedClip(&clipRect, D2D1_ANTIALIAS_MODE_ALIASED);
}
_renderTarget->SetTransform(&transform);
return baselineY;
}
void BackendD2D::_drawTextResetLineRendition(const ShapedRow* row) const noexcept
{
static constexpr D2D1_MATRIX_3X2_F identity{ .m11 = 1, .m22 = 1 };
_renderTarget->SetTransform(&identity);
if (row->lineRendition >= LineRendition::DoubleHeightTop)
{
_renderTarget->PopAxisAlignedClip();
}
}
// Returns the theoretical/design design size of the given `DWRITE_GLYPH_RUN`, relative the the given baseline origin.
// This algorithm replicates what DirectWrite does internally to provide `IDWriteTextLayout::GetMetrics`.
f32r BackendD2D::_getGlyphRunDesignBounds(const DWRITE_GLYPH_RUN& glyphRun, f32 baselineX, f32 baselineY)
{
DWRITE_FONT_METRICS fontMetrics;
glyphRun.fontFace->GetMetrics(&fontMetrics);
if (glyphRun.glyphCount > _glyphMetrics.size())
{
// Growth factor 1.5x.
auto size = _glyphMetrics.size();
size = size + (size >> 1);
size = std::max<size_t>(size, glyphRun.glyphCount);
// Overflow check.
Expects(size > _glyphMetrics.size());
_glyphMetrics = Buffer<DWRITE_GLYPH_METRICS>{ size };
}
glyphRun.fontFace->GetDesignGlyphMetrics(glyphRun.glyphIndices, glyphRun.glyphCount, _glyphMetrics.data(), false);
const f32 fontScale = glyphRun.fontEmSize / fontMetrics.designUnitsPerEm;
f32r accumulatedBounds{
baselineX,
baselineY,
baselineX,
baselineY,
};
for (uint32_t i = 0; i < glyphRun.glyphCount; ++i)
{
const auto& glyphMetrics = _glyphMetrics[i];
const auto glyphAdvance = glyphRun.glyphAdvances ? glyphRun.glyphAdvances[i] : glyphMetrics.advanceWidth * fontScale;
const auto left = static_cast<f32>(glyphMetrics.leftSideBearing) * fontScale;
const auto top = static_cast<f32>(glyphMetrics.topSideBearing - glyphMetrics.verticalOriginY) * fontScale;
const auto right = static_cast<f32>(gsl::narrow_cast<INT32>(glyphMetrics.advanceWidth) - glyphMetrics.rightSideBearing) * fontScale;
const auto bottom = static_cast<f32>(gsl::narrow_cast<INT32>(glyphMetrics.advanceHeight) - glyphMetrics.bottomSideBearing - glyphMetrics.verticalOriginY) * fontScale;
if (left < right && top < bottom)
{
auto glyphX = baselineX;
auto glyphY = baselineY;
if (glyphRun.glyphOffsets)
{
glyphX += glyphRun.glyphOffsets[i].advanceOffset;
glyphY -= glyphRun.glyphOffsets[i].ascenderOffset;
}
accumulatedBounds.left = std::min(accumulatedBounds.left, left + glyphX);
accumulatedBounds.top = std::min(accumulatedBounds.top, top + glyphY);
accumulatedBounds.right = std::max(accumulatedBounds.right, right + glyphX);
accumulatedBounds.bottom = std::max(accumulatedBounds.bottom, bottom + glyphY);
}
baselineX += glyphAdvance;
}
return accumulatedBounds;
}
void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* row, u16 y)
{
const auto widthShift = gsl::narrow_cast<u8>(row->lineRendition != LineRendition::SingleWidth);
const auto cellSize = p.s->font->cellSize;
const auto rowTop = gsl::narrow_cast<i16>(cellSize.y * y);
const auto rowBottom = gsl::narrow_cast<i16>(rowTop + cellSize.y);
const auto textCellCenter = row->lineRendition == LineRendition::DoubleHeightTop ? rowBottom : rowTop;
const auto appendVerticalLines = [&](const GridLineRange& r, FontDecorationPosition pos) {
const auto from = r.from >> widthShift;
const auto to = r.to >> widthShift;
auto posX = from * cellSize.x + pos.position;
const auto end = to * cellSize.x;
D2D1_POINT_2F point0{ 0, static_cast<f32>(textCellCenter) };
D2D1_POINT_2F point1{ 0, static_cast<f32>(textCellCenter + cellSize.y) };
const auto brush = _brushWithColor(r.color);
const f32 w = pos.height;
const f32 hw = w * 0.5f;
for (; posX < end; posX += cellSize.x)
{
const auto centerX = posX + hw;
point0.x = centerX;
point1.x = centerX;
_renderTarget->DrawLine(point0, point1, brush, w, nullptr);
}
};
const auto appendHorizontalLine = [&](const GridLineRange& r, FontDecorationPosition pos, ID2D1StrokeStyle* strokeStyle) {
const auto from = r.from >> widthShift;
const auto to = r.to >> widthShift;
const auto brush = _brushWithColor(r.color);
const f32 w = pos.height;
const f32 centerY = textCellCenter + pos.position + w * 0.5f;
const D2D1_POINT_2F point0{ static_cast<f32>(from * cellSize.x), centerY };
const D2D1_POINT_2F point1{ static_cast<f32>(to * cellSize.x), centerY };
_renderTarget->DrawLine(point0, point1, brush, w, strokeStyle);
};
for (const auto& r : row->gridLineRanges)
{
// AtlasEngine.cpp shouldn't add any gridlines if they don't do anything.
assert(r.lines.any());
if (r.lines.test(GridLines::Left))
{
appendVerticalLines(r, p.s->font->gridLeft);
}
if (r.lines.test(GridLines::Right))
{
appendVerticalLines(r, p.s->font->gridRight);
}
if (r.lines.test(GridLines::Top))
{
appendHorizontalLine(r, p.s->font->gridTop, nullptr);
}
if (r.lines.test(GridLines::Bottom))
{
appendHorizontalLine(r, p.s->font->gridBottom, nullptr);
}
if (r.lines.test(GridLines::Underline))
{
appendHorizontalLine(r, p.s->font->underline, nullptr);
}
if (r.lines.test(GridLines::HyperlinkUnderline))
{
appendHorizontalLine(r, p.s->font->underline, _dottedStrokeStyle.get());
}
if (r.lines.test(GridLines::DoubleUnderline))
{
for (const auto pos : p.s->font->doubleUnderline)
{
appendHorizontalLine(r, pos, nullptr);
}
}
if (r.lines.test(GridLines::Strikethrough))
{
appendHorizontalLine(r, p.s->font->strikethrough, nullptr);
}
}
}
void BackendD2D::_drawCursorPart1(const RenderingPayload& p)
{
if (p.cursorRect.empty())
{
return;
}
const auto cursorColor = p.s->cursor->cursorColor;
if (cursorColor != 0xffffffff)
{
const D2D1_RECT_F rect{
static_cast<f32>(p.cursorRect.left * p.s->font->cellSize.x),
static_cast<f32>(p.cursorRect.top * p.s->font->cellSize.y),
static_cast<f32>(p.cursorRect.right * p.s->font->cellSize.x),
static_cast<f32>(p.cursorRect.bottom * p.s->font->cellSize.y),
};
const auto brush = _brushWithColor(cursorColor);
_drawCursor(p, _renderTarget.get(), rect, brush);
}
}
void BackendD2D::_drawCursorPart2(const RenderingPayload& p)
{
if (p.cursorRect.empty())
{
return;
}
if (p.s->cursor->cursorColor == 0xffffffff)
{
const auto cursorSize = p.cursorRect.size();
if (cursorSize != _cursorBitmapSize)
{
_resizeCursorBitmap(p, cursorSize);
}
const D2D1_POINT_2F target{
static_cast<f32>(p.cursorRect.left * p.s->font->cellSize.x),
static_cast<f32>(p.cursorRect.top * p.s->font->cellSize.y),
};
_renderTarget->DrawImage(_cursorBitmap.get(), &target, nullptr, D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR, D2D1_COMPOSITE_MODE_MASK_INVERT);
}
}
void BackendD2D::_resizeCursorBitmap(const RenderingPayload& p, const til::size newSize)
{
const til::size newSizeInPx{
newSize.width * p.s->font->cellSize.x,
newSize.height * p.s->font->cellSize.y,
};
// CreateCompatibleRenderTarget is a terrific API and does not adopt _any_ of the settings of the
// parent render target (like the AA mode or D2D1_UNIT_MODE_PIXELS). Not sure who came up with that,
// but fact is that we need to set both sizes to override the DPI and fake D2D1_UNIT_MODE_PIXELS.
const D2D1_SIZE_F sizeF{ static_cast<f32>(newSizeInPx.width), static_cast<f32>(newSizeInPx.height) };
const D2D1_SIZE_U sizeU{ gsl::narrow_cast<UINT32>(newSizeInPx.width), gsl::narrow_cast<UINT32>(newSizeInPx.height) };
wil::com_ptr<ID2D1BitmapRenderTarget> cursorRenderTarget;
_renderTarget->CreateCompatibleRenderTarget(&sizeF, &sizeU, nullptr, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, cursorRenderTarget.addressof());
cursorRenderTarget->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
cursorRenderTarget->BeginDraw();
{
const D2D1_RECT_F rect{ 0, 0, sizeF.width, sizeF.height };
const auto brush = _brushWithColor(0xffffffff);
_drawCursor(p, cursorRenderTarget.get(), rect, brush);
}
THROW_IF_FAILED(cursorRenderTarget->EndDraw());
cursorRenderTarget->GetBitmap(_cursorBitmap.put());
_cursorBitmapSize = newSize;
}
void BackendD2D::_drawCursor(const RenderingPayload& p, ID2D1RenderTarget* renderTarget, D2D1_RECT_F rect, ID2D1Brush* brush) noexcept
{
switch (static_cast<CursorType>(p.s->cursor->cursorType))
{
case CursorType::Legacy:
{
const auto height = p.s->cursor->heightPercentage / 100.0f;
rect.top = roundf((rect.top - rect.bottom) * height + rect.bottom);
renderTarget->FillRectangle(&rect, brush);
break;
}
case CursorType::VerticalBar:
rect.right = rect.left + p.s->font->thinLineWidth;
renderTarget->FillRectangle(&rect, brush);
break;
case CursorType::Underscore:
rect.top += p.s->font->underline.position;
rect.bottom = rect.top + p.s->font->underline.height;
renderTarget->FillRectangle(&rect, brush);
break;
case CursorType::EmptyBox:
{
const auto w = static_cast<f32>(p.s->font->thinLineWidth);
const auto wh = w / 2.0f;
rect.left += wh;
rect.top += wh;
rect.right -= wh;
rect.bottom -= wh;
renderTarget->DrawRectangle(&rect, brush, w, nullptr);
break;
}
case CursorType::FullBox:
renderTarget->FillRectangle(&rect, brush);
break;
case CursorType::DoubleUnderscore:
{
auto rect2 = rect;
rect2.top = rect.top + p.s->font->doubleUnderline[0].position;
rect2.bottom = rect2.top + p.s->font->thinLineWidth;
renderTarget->FillRectangle(&rect2, brush);
rect.top = rect.top + p.s->font->doubleUnderline[1].position;
rect.bottom = rect.top + p.s->font->thinLineWidth;
renderTarget->FillRectangle(&rect, brush);
break;
}
default:
break;
}
}
void BackendD2D::_drawSelection(const RenderingPayload& p)
{
u16 y = 0;
for (const auto& row : p.rows)
{
if (row->selectionTo > row->selectionFrom)
{
const D2D1_RECT_F rect{
static_cast<f32>(p.s->font->cellSize.x * row->selectionFrom),
static_cast<f32>(p.s->font->cellSize.y * y),
static_cast<f32>(p.s->font->cellSize.x * row->selectionTo),
static_cast<f32>(p.s->font->cellSize.y * (y + 1)),
};
_fillRectangle(rect, p.s->misc->selectionColor);
}
y++;
}
}
#if ATLAS_DEBUG_SHOW_DIRTY
void BackendD2D::_debugShowDirty(const RenderingPayload& p)
{
_presentRects[_presentRectsPos] = p.dirtyRectInPx;
_presentRectsPos = (_presentRectsPos + 1) % std::size(_presentRects);
for (size_t i = 0; i < std::size(_presentRects); ++i)
{
if (const auto& rect = _presentRects[i])
{
const D2D1_RECT_F rectF{
static_cast<f32>(rect.left),
static_cast<f32>(rect.top),
static_cast<f32>(rect.right),
static_cast<f32>(rect.bottom),
};
const auto color = colorbrewer::pastel1[i] | 0x1f000000;
_fillRectangle(rectF, color);
}
}
}
#endif
#if ATLAS_DEBUG_DUMP_RENDER_TARGET
void BackendD2D::_debugDumpRenderTarget(const RenderingPayload& p)
{
if (_dumpRenderTargetCounter == 0)
{
ExpandEnvironmentStringsW(ATLAS_DEBUG_DUMP_RENDER_TARGET_PATH, &_dumpRenderTargetBasePath[0], gsl::narrow_cast<DWORD>(std::size(_dumpRenderTargetBasePath)));
std::filesystem::create_directories(_dumpRenderTargetBasePath);
}
wchar_t path[MAX_PATH];
swprintf_s(path, L"%s\\%u_%08zu.png", &_dumpRenderTargetBasePath[0], GetCurrentProcessId(), _dumpRenderTargetCounter);
SaveTextureToPNG(_deviceContext.get(), _swapChainManager.GetBuffer().get(), p.s->font->dpi, &path[0]);
_dumpRenderTargetCounter++;
}
#endif
ID2D1SolidColorBrush* BackendD2D::_brushWithColor(u32 color)
{
if (_brushColor != color)
{
_brushWithColorUpdate(color);
}
return _brush.get();
}
ID2D1SolidColorBrush* BackendD2D::_brushWithColorUpdate(u32 color)
{
const auto d2dColor = colorFromU32(color);
_brush->SetColor(&d2dColor);
_brushColor = color;
return _brush.get();
}
void BackendD2D::_fillRectangle(const D2D1_RECT_F& rect, u32 color)
{
const auto brush = _brushWithColor(color);
_renderTarget->FillRectangle(&rect, brush);
}
TIL_FAST_MATH_END
| [
"noreply@github.com"
] | noreply@github.com |
66c2c4e3b5deb81745c6c15aa47c41298a7f4ad3 | 9e2f2e03a169036b3b23253faafb23be2a239458 | /10617 - Again Palindrome/10617 - Again Palindrome.cpp | 4ee36ea1780d92704f63a672053378c16a4a3fec | [] | no_license | M4573R/UVa-Online-Judge-1 | b45bfc327459adedb0ace989bd8fa6c41b9d6be1 | 702fa3e03a3739e7ed5a8c5aa71f963272d95543 | refs/heads/master | 2021-01-16T18:44:30.776083 | 2014-08-22T13:48:11 | 2014-08-22T13:48:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,751 | cpp | //******************************************************************
// Coded by: Huynh Nhat Minh
// Problem Code: 10617 - Again Palindrome
// Verdict: Accepted
//******************************************************************
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cctype>
#include <deque>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <map>
#include <sstream>
#include <cmath>
#include <bitset>
#include <utility>
#include <set>
#include <cctype>
#define PI 3.1415926535897932384626433832795
#define read(x) scanf("%d",&x)
#define out(x) printf("%d\n",x)
#define DEBUG(x) cout << #x << " = " << x << endl
#define FOR(i,a,b) for(int i = a ; i <= b ; i++)
#define mp make_pair
#define ff first
#define ss second
#define pb push_back
#define maxN 123456
#define INF 1000111222
using namespace std;
int tcs;
long long F[100][100];
long long DP(char s[])
{
int sz = strlen(s);
for(int i = 0 ; i < sz ; i++)
for(int j = 0 ; j < sz ; j++)
{
if(i == j) F[i][j] = 1;
else F[i][j] = 0;
}
int cnt = 0;
for(int i = sz-1 ; i >= 0 ; i--)
{
for(int j = i+1 ; j < sz ; j++)
{
F[i][j] = F[i+1][j] + F[i][j-1];
if(s[i] == s[j]) F[i][j]++;
else F[i][j] -= F[i+1][j-1];
}
}
return F[0][sz-1];
}
int main()
{
freopen("10617 - Again Palindrome.INP","r",stdin);
freopen("10617 - Again Palindrome.OUT","w",stdout);
scanf(" %d ",&tcs);
for(int t = 1 ; t <= tcs ; t++)
{
char s[100];
scanf(" %s ",&s);
printf("%lld\n",DP(s));
}
return 0;
}
| [
"nhatminh2947@gmail.com"
] | nhatminh2947@gmail.com |
0d47b9541e0460ce0ea57ace776e074a1a6c3317 | abe3e6ca8b46d4c36e3ac2481fa3dbe7e4f0d0e2 | /Minimal/OBJObject.cpp | 3f17edba5d086c6d41f055d7fdad177dc43553dc | [] | no_license | ColisaNo195/CSE190HW4 | ccdbbeed00e3a9c0a49cc671d108d6674e6aa3f7 | 44cf14f6bdfcde0c53f788c2e1eea3e69bcc08e3 | refs/heads/master | 2020-05-31T22:07:20.326556 | 2019-06-11T12:44:03 | 2019-06-11T12:44:03 | 190,513,303 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,037 | cpp | #include "OBJObject.h"
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <assimp/cimport.h>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <assimp/material.h>
using namespace std;
OBJObject::OBJObject(const char *filepath)
{
const aiScene* scene = aiImportFile(filepath, aiProcessPreset_TargetRealtime_MaxQuality);
if (!scene)
{
std::cerr << "Could not load file " << filepath << std::endl;
return;
}
aiMesh* mesh = scene->mMeshes[0];
for (int i = 0; i < mesh->mNumVertices; ++i) {
aiVector3D vert = mesh->mVertices[i];
aiVector3D norm = mesh->mNormals[i];
vertices.push_back(vert.x);
vertices.push_back(vert.y);
vertices.push_back(vert.z);
normals.push_back(norm.x);
normals.push_back(norm.y);
normals.push_back(norm.z);
}
for (std::uint32_t faceIdx = 0u; faceIdx < mesh->mNumFaces; faceIdx++)
{
tvertices.push_back(mesh->mFaces[faceIdx].mIndices[0u]);
tvertices.push_back(mesh->mFaces[faceIdx].mIndices[1u]);
tvertices.push_back(mesh->mFaces[faceIdx].mIndices[2u]);
}
//parse(filepath);
toWorld = glm::mat4(1.0f);
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &VBO2);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*(vertices.size()), &vertices[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_TRUE, 3 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ARRAY_BUFFER, VBO2);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*(normals.size()), &normals[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_TRUE, 3 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*tvertices.size(), &tvertices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
OBJObject::~OBJObject() {
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
glDeleteBuffers(1, &VBO2);
}
void OBJObject::parse(const char *filepath)
{
FILE *fp;
GLfloat x, y, z;
GLfloat r, g, b;
GLuint t1, t2, t3;//tvertices of triangle corner in vertices
GLuint n1, n2, n3;//tvertices of triangle corner in vertex normals
int c1, c2;
fp = fopen(filepath, "rb");
if (fp == NULL) {
cerr<< "error loading file" <<endl;
exit(-1);
}
while (!feof(fp)) {
c1 = fgetc(fp);
c2 = fgetc(fp);
if ((c1 == 'v') && (c2 == ' ')) {
fscanf(fp, "%f %f %f", &x, &y, &z);
vertices.push_back(x);
vertices.push_back(y);
vertices.push_back(z);
}
else if ((c1 == 'v') && (c2 == 'n')) {
fscanf(fp, "%f %f %f", &x, &y, &z);
//normals.push_back(glm::vec3(x, y, z));
normals.push_back(x);
normals.push_back(y);
normals.push_back(z);
}
else if ((c1 == 'f') && (c2 == ' ')) {
fscanf(fp, "%u//%u %u//%u %u//%u", &t1, &n1, &t2, &n2, &t3, &n3);
tvertices.push_back(t1);
tvertices.push_back(t2);
tvertices.push_back(t3);
//tnormals.push_back(glm::vec3(n1, n2, n3));
//cout << t1<<endl << t2 << endl << t3 << endl;
}
else{
fscanf(fp, "\n");
}
}
for (int i = 0; i < 3; i++) {
//tvertices.pop_back();
}
fclose(fp);
// Populate the face tvertices, vertices, and normals vectors with the OBJ Object data
}
void OBJObject::draw(GLuint shaderProgram, const glm::mat4& projection, const glm::mat4& view)
{
glUseProgram(shaderProgram);
//glDisable(GL_CULL_FACE);
// Calculate the combination of the model and view (camera inverse) matrices
glm::mat4 modelview = view * toWorld;
// We need to calcullate this because modern OpenGL does not keep track of any matrix other than the viewport (D)
// Consequently, we need to forward the projection, view, and model matrices to the shader programs
// Get the location of the uniform variables "projection" and "modelview"
uProjection = glGetUniformLocation(shaderProgram, "projection");
uModelview = glGetUniformLocation(shaderProgram, "modelview");
viewPos = glGetUniformLocation(shaderProgram, "camera_pos");
// Now send these values to the shader program
glUniformMatrix4fv(uProjection, 1, GL_FALSE, &projection[0][0]);
glUniformMatrix4fv(uModelview, 1, GL_FALSE, &modelview[0][0]);
//glUniform3fv(viewPos, 1, &camera_pos[0]);
// Now draw the cube. We simply need to bind the VAO associated with it.
glBindVertexArray(VAO);
// Tell OpenGL to draw with triangles
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
int size; glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
glDrawElements(GL_TRIANGLES, size / sizeof(GLuint), GL_UNSIGNED_INT, 0);// 3 vertices per triangle, 2 triangles per face, 6 faces
// Unbind the VAO when we're done so we don't accidentally draw extra stuff or tamper with its bound buffers
glBindVertexArray(0);
}
void OBJObject::update() {
}
void OBJObject::passing(glm::mat4 I) {
toWorld = I*init();
}
glm::mat4 OBJObject::spin(GLfloat deg)
{
//toWorld = toWorld * glm::rotate(glm::mat4(1.0f), 1.0f / 180.0f * glm::pi<float>(), glm::vec3(0.0f, 1.0f, 0.0f));
this->angle += deg;
if (this->angle > 360.0f || this->angle < -360.0f) this->angle = 0.0f;
// This creates the matrix to rotate the obj
return (glm::rotate(glm::mat4(1.0f), this->angle / 180.0f * glm::pi<float>(), glm::vec3(0.0f, 1.0f, 0.0f)));
}
glm::mat4 OBJObject::move(){
return glm::translate(glm::mat4(1.0f),this->position);
}
glm::mat4 OBJObject::scale() {
return glm::scale(glm::mat4(1.0f), glm::vec3(scales, scales, scales));
}
glm::mat4 OBJObject::rotate() {
return glm::rotate(glm::mat4(1.0f), vel / 180.0f * glm::pi<float>(), axis);
}
glm::mat4 OBJObject::init() {
return glm::scale(glm::mat4(1.0f), glm::vec3(scales, scales, scales))*
glm::translate(glm::mat4(1.0f), glm::vec3(-avgX, -avgY, -avgZ));
} | [
"noreply@github.com"
] | noreply@github.com |
02c760a0b12c4f8cdd2b02e30df6730b3b7e887a | 4e971bd8f059f3fdb1cf29ec2f870cfb4e38021e | /Uppgift 1 - Pathfinding/Projekt/Source/Game/AStar.hpp | ab58a1e617a3d178718722a7fd5ddb189ff74586 | [] | no_license | godofnanners/Spelorienterade-datastrukturer-och-algoritmer | b0a810ba4009049705bd4cca740943b6bb7558e2 | 618054d8a301c82896c364f720403cc84f91aa1b | refs/heads/master | 2022-12-29T03:04:15.430220 | 2020-10-21T00:05:53 | 2020-10-21T00:05:53 | 287,136,220 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,151 | hpp | #pragma once
#include <vector>
#include <map>
#include <set>
#include "MinHeap.hpp"
#include <limits>
namespace CommonUtilities
{
static bool CheckIfInsideMap(int aIndex);
static bool CheckIfVerticeRealyIsNeighbour(int aNeighbourIndex, int aCurrentIndex);
enum class eStatus { Unvisited, Open, Closed };
enum class eHeuristics { eManhattan, eEuclidian };
struct AStarNode
{
int myPredecessor;
int myG;
int myH;
eStatus myStatus;
int myIndex;
bool operator< (const AStarNode& aNode) const
{
if (myG + myH < aNode.myG + aNode.myH)
{
return true;
}
return false;
}
};
static int Manhattan(int aNodeX, int aNodeY, int aGoalX, int aGoalY)
{
return abs(aNodeX - aGoalX) + abs(aNodeY - aGoalY);
}
static int Euclidian(int aNodeX, int aNodeY, int aGoalX, int aGoalY)
{
return sqrt(pow((aNodeX - aGoalX), 2) + pow((aNodeY - aGoalY), 2));
}
static const int MapWidth = 20; static const int MapHeight = 20; static const int TileCount = MapWidth * MapHeight;
enum class Tile { Impassable, Passable };
static std::vector<int> AStar(const std::vector<Tile>& aMap, int aStartIndex, int anEndIndex, eHeuristics aHeuristics = eHeuristics::eManhattan)
{
std::vector<int>MyPath;
std::array<AStarNode, MapWidth* MapHeight> myNodes;
MinHeap<AStarNode> minHeap;
int goalX = anEndIndex - ((MapWidth) * static_cast<int>(anEndIndex / (MapWidth)));
int goalY = static_cast<int>(anEndIndex / MapHeight);
for (size_t i = 0; i < aMap.size(); i++)
{
myNodes[i].myIndex = i;
myNodes[i].myG = std::numeric_limits<int>::infinity();
int nodeY = static_cast<int>(i / MapHeight);
int nodeX = i - ((MapWidth) * static_cast<int>(i / (MapWidth )));
myNodes[i].myH = (aHeuristics == eHeuristics::eManhattan ? Manhattan(nodeX, nodeY, goalX, goalY) : Euclidian(nodeX, nodeY, goalX, goalY));
myNodes[i].myStatus = eStatus::Unvisited;
myNodes[i].myPredecessor = -1;
}
myNodes[aStartIndex].myG = 0;
myNodes[aStartIndex].myPredecessor = aStartIndex;
minHeap.Enqueue(myNodes[aStartIndex]);
while (minHeap.GetSize() > 0)
{
AStarNode newSmallest = minHeap.Dequeue();
myNodes[newSmallest.myIndex].myStatus = eStatus::Closed;
if (newSmallest.myIndex == anEndIndex)
{
int currentNode = newSmallest.myIndex;
do
{
MyPath.push_back(currentNode);
currentNode = myNodes[currentNode].myPredecessor;
} while (currentNode != aStartIndex);
MyPath.push_back(aStartIndex);
std::reverse(MyPath.begin(), MyPath.end());
return MyPath;
}
std::array<int, 4> neighbours;
neighbours[0] = newSmallest.myIndex - MapWidth;
neighbours[1] = newSmallest.myIndex + MapWidth;
neighbours[2] = newSmallest.myIndex + 1;
neighbours[3] = newSmallest.myIndex - 1;
for (int i = 0; i < neighbours.size(); i++)
{
if (CheckIfInsideMap(neighbours[i])
&& aMap[neighbours[i]] == Tile::Passable
&& myNodes[neighbours[i]].myStatus != eStatus::Closed
&& CheckIfVerticeRealyIsNeighbour(neighbours[i], newSmallest.myIndex))
{
int altPath = 1 + newSmallest.myG;
if (myNodes[neighbours[i]].myStatus == eStatus::Unvisited)
{
//If its the first time encountering node
myNodes[neighbours[i]].myG = altPath;
myNodes[neighbours[i]].myPredecessor = newSmallest.myIndex;
myNodes[neighbours[i]].myStatus = eStatus::Open;
minHeap.Enqueue(myNodes[neighbours[i]]);
}
else if (myNodes[neighbours[i]].myStatus == eStatus::Open && altPath < myNodes[neighbours[i]].myG)
{
//If node already is in heap
myNodes[neighbours[i]].myG = altPath;
myNodes[neighbours[i]].myPredecessor = newSmallest.myIndex;
minHeap.Remake();
}
}
}
}
return MyPath;
}
static bool CheckIfInsideMap(int aIndex)
{
if (aIndex < MapWidth * MapHeight && aIndex >= 0)
{
return true;
}
return false;
}
static bool CheckIfVerticeRealyIsNeighbour(int aNeighbourIndex, int aCurrentIndex)
{
if (abs((aCurrentIndex % MapWidth) - (aNeighbourIndex % MapWidth)) != 1 && abs(aCurrentIndex - aNeighbourIndex) != MapWidth)
{
return false;
}
return true;
}
} | [
"casper.martensson@telia.com"
] | casper.martensson@telia.com |
7729e8e39ee63004f58dc74e98888ab260f90625 | 8a5f4b502ef2dccbf4a39676c19bee514cfc0065 | /old/src/ui/ncurses/articlepanel.cxx | 944eb450a37fffbf66dd8eca0cc7cb5772ee5437 | [
"MIT"
] | permissive | WovenTales/agora | 3c8b99ac3eabe11cb5c527611798b81d7ab92004 | 1c6d16ddcc160347ca6a42e24d26bd67595e9fb2 | refs/heads/master | 2020-03-28T01:28:40.585551 | 2015-12-14T17:55:34 | 2015-12-14T17:55:34 | 37,218,542 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,202 | cxx | #include <ui/ncurses/articlepanel.hxx>
#include <agora.hxx>
#include <article.hxx>
#include <database.hxx>
#include <ui/ncurses/ui.hxx>
#include <curses.h>
using namespace agora;
using namespace std;
int NcursesArticlePanel::height() {
return LINES - y();
}
int NcursesArticlePanel::width() {
return COLS - x();
}
int NcursesArticlePanel::x() {
return (NcursesUI::getFocus() == Panel::DatabasePanel ? DBPANEL_WIDTH_ACTIVE : DBPANEL_WIDTH_MINIMIZED);
}
int NcursesArticlePanel::y() {
return (NcursesUI::getFocus() == Panel::FeedPanel ? FEEDPANEL_HEIGHT_ACTIVE : FEEDPANEL_HEIGHT_MINIMIZED);
}
/*! \todo Implement
*/
bool NcursesArticlePanel::scrollTab(bool down) {
return false;
}
/*! \todo Convert HTML to formatted text (check http://www.blackbeltcoder.com/Articles/strings/convert-html-to-text)
* \todo Split for loop into other function, and only call in update\n
* This would probably best be handled by inserting control characters at line
* breakpoints for each width, and saving it as a single string
*/
void NcursesArticlePanel::fill() {
int s = content.size();
vector<string> split;
int y = 1;
int h = height() - 1;
int w = width() - 4;
for (string line : content) {
// Draw arrows if content exceeds window
if (y >= h) {
//! \todo Could definitely look better
mvwaddch(panel, height() - 2, width() - 1, ACS_UARROW);
mvwaddch(panel, height() - 1, width() - 1, ACS_DARROW);
break;
}
//! \todo Implement scrollable view
if (line.size() <= w) { // If entire line can fit in window
mvwaddstr(panel, y, 2, line.c_str());
} else {
// Split string into individual words
split = splitString(line, ' ');
int c = split.size() - 1;
// Reusing line here as old value now in split
line = "";
for (int j = 0; j < c; ++j) {
if (line.empty()) {
line = split[j];
} else {
line += " " + split[j];
}
// If the line plus the next word does not fit in the window
if ((line.size() + split[j + 1].size() + 1) > w) {
if (line.size() > w) {
// Current line may still be longer if it's a single word
mvwaddnstr(panel, y, 2, line.c_str(), w - 3);
waddstr(panel, "...");
} else {
mvwaddstr(panel, y, 2, line.c_str());
}
// Setup for remaining part of split
line = "";
++y;
}
// Ensure we don't spill out the bottom
if (y == h) {
break;
}
}
// Add the last word and print if we have space
if (y < h) {
mvwaddstr(panel, y, 2, (line + (line.empty() ? "" : " ") + split[c]).c_str());
}
}
++y;
}
}
/*! \param db the Database containing the desired article
* \param aID the article ID to search for
*/
void NcursesArticlePanel::loadArticle(const Database &db, const std::string &aID) {
// We only need to display some of the data
Database::DataList t = db.getColumns({ Article::columns["title"] }, {{ Article::columns.getID(), aID }});
//! \todo Is this really the test we want?
if (t.size()) { // t.size != 0
tabs.push_back(t[0][Article::columns["title"]]);
//! \todo Data retrieval methods are inconsistent
content = splitString(db.getArticle(aID).getContent());
++activeTab;
}
}
| [
"woventales@gmail.com"
] | woventales@gmail.com |
76fb1c9de7b85a17104428a2253e05714e209bcb | 27a62444b82e2a2a7cadb3aa938269da53c8307f | /examples/cxx/value_store.cpp | f717e281993a4e1da6e89e4526a9fb7ca98ee8da | [
"ISC"
] | permissive | becm/mpt-base | 509db613316c2d9539342ec8fe27cad2925c9a24 | 6dbba929c1a25d7f01aeb58774068cc76171fdae | refs/heads/master | 2023-08-29T04:35:34.110477 | 2023-08-04T11:23:59 | 2023-08-04T11:23:59 | 31,544,117 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,398 | cpp | /*!
* MPT plot library
* type-safe value_store assignments
*/
#include <iostream>
#ifndef MPT_INCLUDE
# define MPT_INCLUDE(x) <mpt/x>
#endif
#include MPT_INCLUDE(values.h)
#ifdef __GLIBC__
# include <mcheck.h>
#else
# define mtrace()
#endif
using namespace mpt;
extern int main(int , char * const [])
{
int ret = 0;
mtrace();
value_store s;
// set values at specified offset
double v[] = { 1.0, 2.0, 3.14, 4e-123 };
double *ptr = s.set(span<const double>(v + 1, 3), 2);
ret |= !(ptr && ptr[2] == v[3]);
// content type is defined
span<double> sd(ptr - 2, s.element_count());
std::cout << static_cast<char>(s.type()) << "@[" << sd << ']' << std::endl;
// same type area extension
content<double> *cd = s.reserve<double>(8);
std::cout << static_cast<char>(s.type()) << "@[" << cd->data() << ']' << std::endl;
// conflicting type assign fails
int i[] = { 1, 2, 3 };
int *iptr = s.set(span<const int>(i, 3), 0);
ret |= !(!iptr);
// new type reserve replaces old data
content<int> *ci = s.reserve<int>(3);
int *in_set = s.set(span<const int>(i + 1, 2), 4);
ci = s.reserve<int>();
std::cout << static_cast<char>(s.type()) << "@[" << ci->data() << ']' << std::endl;
ret |= !(in_set && i[1] == in_set[0]);
content<uint16_t> *cq = s.reserve<uint16_t>();
std::cout << static_cast<char>(s.type()) << "@[" << cq->data() << ']' << std::endl;
return ret;
}
| [
"becm@gmx.de"
] | becm@gmx.de |
656a1b11e5b16d97e7db4b288c7c2698e21566e1 | f6dc89cd28df4658e33857c46784e7fc55188018 | /05/code/program5_19.cpp | 919d3c8389680c8b62947e40aae928e39c221035 | [] | no_license | positronn/gaddys08ed | 313c777b69faefe6db6a209d19a2a21cb88b0e51 | b3849847142e6770083e87ed86ef81bbd008018a | refs/heads/master | 2022-06-10T17:56:24.337709 | 2020-05-10T06:03:45 | 2020-05-10T06:03:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 814 | cpp | // this program uses a loop to write multiple values to a file
#include <iostream>
#include <fstream>
using namespace std;
int main() {
// vars and objects
ofstream outputFile;
int numberOfDays;
double sales;
// get number of days
cout << "For how many days do you have sales? ";
cin >> numberOfDays;
// open the output file
outputFile.open("Sales.txt");
// loop once for each day of sales
for (int count = 1; count <= numberOfDays; count++) {
// get the sales amount for a day
cout << "Enter the sales for day " << count << ": ";
cin >> sales;
// write the sales amount to the file
outputFile << sales << endl;
}
// close the file
outputFile.close();
cout << "Data written to Sales.txt\n";
return 0;
} | [
"mar.dls@tutamail.com"
] | mar.dls@tutamail.com |
0ba86f3dd68c9f02fbf1f45c669259862378d7b4 | 8bbe884268d4a4b4354cdd23c9e1973692528838 | /include/db/IDWithType.h | e259e49a539b652b4d9b87832e0391b650c6cf6d | [] | no_license | bkrmendy/structur3D | 12bea5c0caa719f699c057172f4ce37cb2255a30 | 535b73f05f2106dee10c3ccd3ec81882f9dd4f6c | refs/heads/master | 2023-02-11T14:52:02.395482 | 2020-12-05T17:43:59 | 2020-12-05T17:43:59 | 317,204,670 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 428 | h | //
// IDWithName.h
// cross-platform-game
//
// Created by Berci on 2020. 11. 14..
// Copyright © 2020. Berci. All rights reserved.
//
#ifndef IDWithName_h
#define IDWithName_h
#include "./NodeType.h"
#include "../data/Base.h"
namespace S3D {
struct IDWithType {
const ID uid;
const NodeType type;
IDWithType(const ID& uid, const NodeType& type) : uid{uid}, type{type} { }
};
}
#endif /* IDWithName_h */
| [
"korber314@gmail.com"
] | korber314@gmail.com |
1386793a096eae2879e53452c7b271f40ca22b6f | a6029563f664d717e202237c3fd7a3d2d66ecd38 | /src/core/mapper/MAPPER083.h | fec719941ff47e7a42ca5b9555fa61ec0a8050ee | [] | no_license | suxinde2009/MyNES | b5e453cb550fa177dcf9330c06cf48571102f394 | 56d0859535b5b5e9afd25382a9ff044c1976d932 | refs/heads/master | 2020-03-08T20:46:28.598734 | 2013-01-15T16:17:21 | 2013-01-15T16:17:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 56 | h | class MAPPER083 : public MAPPER
{
public:
protected:
}; | [
"JQBar@JQBarmatoiMac.local"
] | JQBar@JQBarmatoiMac.local |
c05332b9bf9b1c093ae1026e408fa3949fcfa4f1 | 82ef35d186102b3b1ce15f836be2528806bb5bba | /chat-server/configmanager.cpp | 3d638353f8680114c3590d8241c7c3e9f7bf29b8 | [] | no_license | karennik98/final_network_chat | 168d1f7495d2a45ace8d0797c21f6718487b5aca | 3cea1296d7a91c9a3f8853f7a6897a4b94f71dbf | refs/heads/master | 2022-03-29T12:23:07.098645 | 2019-12-26T16:18:35 | 2019-12-26T16:18:35 | 230,149,331 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 789 | cpp | #include "configmanager.h"
ConfigManager::ConfigManager(QObject *parent) :
QObject(parent)
{
p_ChatServerConfig = new ChatServerConfig;
p_LoggerConfig = new LoggerConfig;
}
ConfigManager::~ConfigManager()
{
delete p_ChatServerConfig;
}
void ConfigManager::ReadConfig()
{
p_ChatServerConfig->port = m_ServerSettings.value("/tcpserver/port", 33033).toUInt();
p_LoggerConfig->Path = m_ServerSettings.value("/logger/Path", "Logs").toString();
}
void ConfigManager::sendSignals()
{
emit configChatServerSignal(p_ChatServerConfig);
emit configLoggerSignal(p_LoggerConfig);
}
void ConfigManager::WriteConfig()
{
m_ServerSettings.setValue("/tcpserver/port", p_ChatServerConfig->port);
m_ServerSettings.setValue("/logger/Path", p_LoggerConfig->Path);
}
| [
"karen.nikoghosyan.98@gmail.com"
] | karen.nikoghosyan.98@gmail.com |
7f6bad2e61301bde0acd8e84951d1bc4bd4697e6 | 4c25432a6d82aaebd82fd48e927317b15a6bf6ab | /data/dataset_2017/dataset_2017_8/vudduu/3264486_5736519012712448_vudduu.cpp | fa0bcf40b9067bca65fef0ebed33b53ac727931d | [] | no_license | wzj1988tv/code-imitator | dca9fb7c2e7559007e5dbadbbc0d0f2deeb52933 | 07a461d43e5c440931b6519c8a3f62e771da2fc2 | refs/heads/master | 2020-12-09T05:33:21.473300 | 2020-01-09T15:29:24 | 2020-01-09T15:29:24 | 231,937,335 | 1 | 0 | null | 2020-01-05T15:28:38 | 2020-01-05T15:28:37 | null | UTF-8 | C++ | false | false | 1,216 | cpp | // vudduu - codejam 2017 qualification round
// Problem A
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <functional>
#include <algorithm>
#include <numeric>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <stdio.h>
#include <string.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a),_##i=(b);i<_##i;++i)
#define F(i,a) FOR(i,0,a)
#define ALL(x) x.begin(),x.end()
#define PB push_back
#define MP make_pair
#define S size()
typedef long long LL;
string str;
int k;
void solve() {
cin >> str >> k;
int n = str.S;
int res = 0;
for (int i = 0; i <= n - k ;i++) {
if (str[i] != '+') {
F(j, k) str[i + j] = (str[i + j] == '+') ? '-' : '+';
res++;
}
}
bool flag = true;
F(i, n) {
if (str[i] != '+') flag = false;
}
if (flag) printf("%d\n", res);
else printf("IMPOSSIBLE\n");
}
int main() {
int T;
scanf("%d", &T);
for(int cas=1; cas<=T ;cas++) {
printf("Case #%d: ", cas);
solve();
}
}
| [
"e.quiring@tu-bs.de"
] | e.quiring@tu-bs.de |
82b40c5d7a3919eed2f0aed26e0cfedba877c458 | 5c18cc0967f87247f43e4b26ead23154417f708b | /qt_project/emb_rust/file_io.cpp | 3d3da85ad2d3b65b98cd2a8a23e7504ff9515518 | [] | no_license | jamyang838/yocto_rpi | 35f72a38817d0466b26a6aa04a9ec2480240f288 | 01722124db56b558316fae35aa10b88f53a7eb93 | refs/heads/master | 2023-03-11T10:35:47.976624 | 2021-02-22T06:40:20 | 2021-02-22T06:40:20 | 275,737,792 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,172 | cpp | #include "file_io.h"
file_io::file_io()
{
initial_recipes();
}
int file_io::get_value(int index, file_io::parameter p)
{
int value = jsonArray[index].toObject().take(convert_parameter_tostring(p)).toInt();
file_io::is_valid(p, value);
return value;
}
void file_io::save_recipes()
{
QJsonDocument doc(jsonArray);
QString strJson(doc.toJson());
std::ofstream ofs(FILE_NAME);
ofs << strJson.toStdString().data();
ofs.close();
get_Jsonfile();
}
void file_io::initial_recipes()
{
for(int i=0; i <10; i++)
{
QJsonObject _jsonObj;
_jsonObj.insert(convert_parameter_tostring(parameter::POWER), DEF_POWER);
_jsonObj.insert(convert_parameter_tostring(parameter::FREQUENCY), DEF_FREQUENCY);
_jsonObj.insert(convert_parameter_tostring(parameter::RATE), DEF_SCAN_RATE);
_jsonObj.insert(convert_parameter_tostring(parameter::RANGE), DEF_SCAN_RANGE);
jsonArray.append(_jsonObj);
}
if(QFileInfo(FILE_NAME).exists()){
//The file exists
get_Jsonfile();
}
else{
save_recipes();
}
}
void file_io::update_recipe(int index, int power, int frequency, int rate, int range)
{
QJsonArray _array;
for(int i=0; i <10; i++)
{
QJsonObject _obj;
if(i == index)
{
_obj.insert(convert_parameter_tostring(parameter::POWER), power);
//_obj.insert(convert_parameter_tostring(parameter::POWER), 777);
_obj.insert(convert_parameter_tostring(parameter::FREQUENCY), frequency);
_obj.insert(convert_parameter_tostring(parameter::RATE), rate);
_obj.insert(convert_parameter_tostring(parameter::RANGE), range);
}
else{
_obj = jsonArray[i].toObject();
}
_array.append(_obj);
}
jsonArray.swap(_array);
}
bool file_io::is_valid(parameter p, int value)
{
switch (p) {
case POWER:
return (value >= MIN_POWER) && (value <= MAX_POWER );
break;
case FREQUENCY:
return (value >= MIN_FREQUENCY) && (value <= MAX_FREQUENCY );
break;
case RATE:
return (value >= MIN_SCAN_RATE) && (value <= MAX_SCAN_RATE );
break;
case RANGE:
return (value >= MIN_SCAN_RANGE) && (value <= MAX_SCAN_RANGE );
break;
default:
return false;
break;
}
}
QString file_io::convert_parameter_tostring(parameter p)
{
QString result;
switch (p) {
case POWER:
result = "power";
break;
case FREQUENCY:
result = "frequency";
break;
case RATE:
result = "rate";
break;
case RANGE:
result = "range";
break;
default:
break;
}
return result;
}
void file_io::get_Jsonfile()
{
QFile savefile(FILE_NAME);
savefile.open(QIODevice::ReadOnly);
QTextStream in(&savefile);
QString strReply = in.readAll();
QStringList propertyNames;
QStringList propertyKeys;
//QString strReply = (QString)reply->readAll();
QJsonDocument jsonResponse = QJsonDocument::fromJson(strReply.toUtf8());
jsonArray = jsonResponse.array();
}
| [
"jamyang838@icloud.com"
] | jamyang838@icloud.com |
9e253442a9d7be82e2c771f9295d0c47340396ea | adbd75fb48eff3e9df77b83c4ca99f3199233b45 | /Jarce_Cplus/sortkdb.cpp | 89e73a8fbff92878c67cd5b467db1006795c6cbe | [] | no_license | Lirunhua/Jarce | 6fe04e47a4273357e9eb8332c34fd327452eb841 | b7d7ff37b34d3ea855d47fc06ced21f0e1ce69f8 | refs/heads/master | 2021-07-24T05:40:10.893378 | 2017-11-06T01:55:13 | 2017-11-06T01:55:13 | 109,631,573 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,399 | cpp | /*
* File: sortkdb.cpp
* Author: Administrator
*
* Created on 2016年12月3日, 下午9:43
*/
#include <assert.h>
#include <math.h>
#include <set>
#include <algorithm>
#include <stdlib.h>
#include "sortkdb.h"
#include "utils.h"
#include "correlationMeasures.h"
#include "globals.h"
sortkdb::sortkdb() : pass_(1) {
}
sortkdb::sortkdb(char*const*& argv, char*const* end) : pass_(1) {
name_ = "sortkdb";
// defaults
k_ = 1;
sum_unmi = 0.0;
sum_uncmi = 0.0;
union_localkdb = false;
// get arguments
while (argv != end) {
if (*argv[0] != '-') {
break;
} else if (argv[0][1] == 'k') {
getUIntFromStr(argv[0] + 2, k_, "k");
} else if (streq(argv[0] + 1, "unloc")) {
union_localkdb = true;
} else {
break;
}
name_ += argv[0];
++argv;
}
}
sortkdb::~sortkdb(void) {
}
void sortkdb::getCapabilities(capabilities &c) {
c.setCatAtts(true); // only categorical attributes are supported at the moment
}
class miCmpClass11 {
public:
miCmpClass11(std::vector<float> *m) {
mi = m;
}
bool operator()(CategoricalAttribute a, CategoricalAttribute b) {
return (*mi)[a] > (*mi)[b];
}
private:
std::vector<float> *mi;
};
void sortkdb::reset(InstanceStream &is) {
instanceStream_ = &is;
const unsigned int noCatAtts = is.getNoCatAtts();
noCatAtts_ = noCatAtts;
noClasses_ = is.getNoClasses();
k_ = min(k_, noCatAtts_ - 1); // k cannot exceed the real number of categorical attributes - 1
// initialise distributions
parents_.resize(noCatAtts);
for (CategoricalAttribute a = 0; a < noCatAtts; a++) {
parents_[a].clear();
}
/*初始化各数据结构空间*/
dist_.reset(is); //
dist_1.reset(is); //
classDist_.reset(is);
trainingIsFinished_ = false;
}
/// primary training method. train from a single instance. used in conjunction with initialisePass and finalisePass
/*通过训练集来填写数据空间*/
void sortkdb::train(const instance &inst) {
// printf("train:\n");
dist_.update(inst);
dist_1.update(inst);
classDist_.update(inst);
}
/// must be called to initialise a pass through an instance stream before calling train(const instance). should not be used with train(InstanceStream)
void sortkdb::initialisePass() {
assert(trainingIsFinished_ == false);
}
/// must be called to finalise a pass through an instance stream using train(const instance). should not be used with train(InstanceStream)
void sortkdb::finalisePass() {
//printf("--------------------finalPass:------------------------\n");
assert(trainingIsFinished_ == false);
// calculate the mutual information from the xy distribution
std::vector<float> mi; //互信息
getMutualInformation(dist_.xxyCounts.xyCounts, mi);
//联合互信息，二维
crosstab<float> mi_xxy = crosstab<float>(noCatAtts_); //联合互信息I(Xi,Xj;Y)
getUnionMI(dist_.xxyCounts, mi_xxy);
crosstab3D<float> un_cmi = crosstab3D<float>(noCatAtts_); //联合条件互信息I(Xi,Xj;Xk|Y)
getUnionCmi(dist_, un_cmi);
dist_.clear();
// for (CategoricalAttribute k = 0; k < noCatAtts_; k++) {
// printf("k=%d\n",k);
// for (CategoricalAttribute i = 0; i < noCatAtts_; i++) {
// for (CategoricalAttribute j = 0; j < noCatAtts_; j++) {
// printf("%lf\t",un_cmi[k][i][j]);
// }
// printf("\n");
// }
// printf("\n");
// }
// sort the attributes on MI with the class
std::vector<CategoricalAttribute> order;
std::vector<bool> InOrder;
InOrder.assign(noCatAtts_, false);
order.clear();
double maxmi = -std::numeric_limits<double>::max();
CategoricalAttribute root = 0xFFFFFFFFUL;
for (CategoricalAttribute i = 0; i < noCatAtts_; i++) {
if (maxmi < mi[i]) {
maxmi = mi[i];
root = i;
}
}
order.push_back(root);
InOrder[root] = true;
double maxunmi = -std::numeric_limits<double>::max();
CategoricalAttribute root1 = 0xFFFFFFFFUL;
for (CategoricalAttribute i = 0; i < noCatAtts_; i++) {
if (i != order[0]) {
if (maxunmi < mi_xxy[order[0]][i]) {
maxunmi = mi_xxy[order[0]][i];
root1 = i;
}
}
}
order.push_back(root1);
InOrder[root1] = true;
unsigned int boundary = noCatAtts_;
while (order.size() != boundary) {
maxunmi = -std::numeric_limits<double>::max();
CategoricalAttribute node = 0xFFFFFFFFUL;
for (CategoricalAttribute j = 0; j < noCatAtts_; j++) {
double sum = 0.0;
if (!InOrder[j]) {
for (CategoricalAttribute i = 0; i < order.size(); i++) {
sum += mi_xxy[order[i]][j];
}
//printf("%lf\t%d\n",sum,j);
if (maxunmi < sum) {
maxunmi = sum;
node = j;
}
}
}
//printf("-------->%lf\t%d\n",maxunmi,node);
order.push_back(node);
InOrder[node] = true;
}
// printf("order:\t");
// for (CategoricalAttribute a = 0; a < order.size(); a++) {
// printf("%d\t", order[a]);
// }
// printf("\n");
for (int a = noCatAtts_ - 1; a >= 0; a--) {
order_.push_back(order[a]);
}
std::vector<CategoricalAttribute> used_nodes;
std::vector<bool> waiting_nodes;
waiting_nodes.assign(noCatAtts_, true);
used_nodes.push_back(order[0]);
used_nodes.push_back(order[1]);
parents_[order[1]].push_back(order[0]);
// printf("%d\n", order[0]);
// printf("%d\t:\t%d\n", order[1], order[0]);
waiting_nodes[order[0]] = false;
waiting_nodes[order[1]] = false;
// proper KDB assignment of parents
while (used_nodes.size() != boundary) {
CategoricalAttribute fa1 = 0xFFFFFFFFUL;
CategoricalAttribute fa2 = 0xFFFFFFFFUL;
CategoricalAttribute ch = 0xFFFFFFFFUL;
for (std::vector<CategoricalAttribute>::const_iterator it = order.begin(); it != order.end(); it++) {
double maxuncmi = -std::numeric_limits<double>::max();
if (waiting_nodes[*it]) {
for (CategoricalAttribute xi = 0; xi < used_nodes.size(); xi++) { //待选父节点
for (CategoricalAttribute xj = xi + 1; xj < used_nodes.size(); xj++) {
if (maxuncmi < un_cmi[*it][used_nodes[xi]][used_nodes[xj]]) {
maxuncmi = un_cmi[*it][used_nodes[xi]][used_nodes[xj]];
fa1 = used_nodes[xi];
fa2 = used_nodes[xj];
ch = *it;
}
}
}
// printf("%d\t:\t%d\t%d\t", ch, fa1, fa2);
// printf("%lf\n", un_cmi[ch][fa1][fa2]);
parents_[ch].push_back(fa1);
parents_[ch].push_back(fa2);
used_nodes.push_back(ch);
waiting_nodes[ch] = false;
}
}
}
// printf("parents_incpp:\n");
// for (unsigned int i = 0; i < noCatAtts_; i++) {
// if (parents_[i].size() == 0) {
// printf("parents_[%d][0]\tY\n", i);
// }
// if (parents_[i].size() == 1) {
// printf("parents_[%d][0]=%d\n", i, parents_[i][0]);
// }
// if (parents_[i].size() == 2) {
// printf("parents_[%d][0]=%d\tparents_[%d][1]=%d\n", i, parents_[i][0], i, parents_[i][1]);
// }
// }
trainingIsFinished_ = true;
}
/// true iff no more passes are required. updated by finalisePass()
bool sortkdb::trainingIsFinished() {
return trainingIsFinished_;
}
void sortkdb::classify(const instance& inst, std::vector<double> &posteriorDist) {
// calculate the class probabilities in parallel
// P(y)
for (CatValue y = 0; y < noClasses_; y++) {
posteriorDist[y] = classDist_.p(y) * (std::numeric_limits<double>::max() / 2.0);
}
for (unsigned int x1 = 0; x1 < noCatAtts_; x1++) {
for (CatValue y = 0; y < noClasses_; y++) {
if (parents_[x1].size() == 0) {
// printf("PARent=0 \n");
posteriorDist[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y); // p(a=v|Y=y) using M-estimate
} else if (parents_[x1].size() == 1) {
// printf("PARent=1 \n");
const InstanceCount totalCount1 = dist_1.xxyCounts.xyCounts.getCount(parents_[x1][0], inst.getCatVal(parents_[x1][0]));
if (totalCount1 == 0) {
posteriorDist[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y);
} else {
posteriorDist[y] *= dist_1.xxyCounts.p(x1, inst.getCatVal(x1), parents_[x1][0], inst.getCatVal(parents_[x1][0]), y); // p(x1=v1|Y=y, x2=v2) using M-estimate
}
} else if (parents_[x1].size() == 2) {
// printf("PARent=2 \n");
const InstanceCount totalCount1 = dist_1.xxyCounts.getCount(parents_[x1][0], inst.getCatVal(parents_[x1][0]), parents_[x1][1], inst.getCatVal(parents_[x1][1]));
if (totalCount1 == 0) {
const InstanceCount totalCount2 = dist_1.xxyCounts.xyCounts.getCount(parents_[x1][0], inst.getCatVal(parents_[x1][0]));
if (totalCount2 == 0) {
posteriorDist[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y);
} else {
posteriorDist[y] *= dist_1.xxyCounts.p(x1, inst.getCatVal(x1), parents_[x1][0], inst.getCatVal(parents_[x1][0]), y);
}
} else {
posteriorDist[y] *= dist_1.p(x1, inst.getCatVal(x1), parents_[x1][0], inst.getCatVal(parents_[x1][0]), parents_[x1][1], inst.getCatVal(parents_[x1][1]), y);
}
}
}
}
normalise(posteriorDist);
//局部
if (union_localkdb == true) {
parents_1.resize(noCatAtts_);
for (CategoricalAttribute a = 0; a < noCatAtts_; a++) {
parents_1[a].clear();
}
std::vector<float> mi_loc; //互信息
getMutualInformationloc(dist_1.xxyCounts.xyCounts, mi_loc, inst);
//联合互信息，二维
crosstab<float> mi_xxy_loc = crosstab<float>(noCatAtts_); //局部联合互信息I(xi,xj;Y)
getUnmi_loc(dist_1.xxyCounts, mi_xxy_loc, inst);
crosstab3D<float> un_cmi_loc = crosstab3D<float>(noCatAtts_); //局部联合条件互信息I(xi,xj;xk|Y)
getUnionCmi_loc(dist_1, un_cmi_loc, inst);
// sort the attributes on MI with the class
std::vector<CategoricalAttribute> order_loc;
std::vector<bool> InOrder_loc;
InOrder_loc.assign(noCatAtts_, false);
order_loc.clear();
double maxmi = -std::numeric_limits<double>::max();
CategoricalAttribute root = 0xFFFFFFFFUL;
for (CategoricalAttribute i = 0; i < noCatAtts_; i++) {
if (maxmi < mi_loc[i]) {
maxmi = mi_loc[i];
root = i;
}
}
order_loc.push_back(root);
InOrder_loc[root] = true;
double maxunmi = -std::numeric_limits<double>::max();
CategoricalAttribute root1 = 0xFFFFFFFFUL;
for (CategoricalAttribute i = 0; i < noCatAtts_; i++) {
if (i != order_loc[0]) {
if (maxunmi < mi_xxy_loc[order_loc[0]][i]) {
maxunmi = mi_xxy_loc[order_loc[0]][i];
root1 = i;
}
}
}
order_loc.push_back(root1);
InOrder_loc[root1] = true;
unsigned int boundary_loc = noCatAtts_;
while (order_loc.size() != boundary_loc) {
maxunmi = -std::numeric_limits<double>::max();
CategoricalAttribute node = 0xFFFFFFFFUL;
for (CategoricalAttribute j = 0; j < noCatAtts_; j++) {
double sum = 0.0;
if (!InOrder_loc[j]) {
for (CategoricalAttribute i = 0; i < order_loc.size(); i++) {
sum += mi_xxy_loc[order_loc[i]][j];
}
if (maxunmi < sum) {
maxunmi = sum;
node = j;
}
}
}
order_loc.push_back(node);
InOrder_loc[node] = true;
}
std::vector<CategoricalAttribute> used_nodes_loc;
std::vector<bool> waiting_nodes_loc;
waiting_nodes_loc.assign(noCatAtts_, true);
used_nodes_loc.push_back(order_loc[0]);
used_nodes_loc.push_back(order_loc[1]);
parents_1[order_loc[1]].push_back(order_loc[0]);
waiting_nodes_loc[order_loc[0]] = false;
waiting_nodes_loc[order_loc[1]] = false;
// proper KDB assignment of parents
while (used_nodes_loc.size() != boundary_loc) {
CategoricalAttribute fa1 = 0xFFFFFFFFUL;
CategoricalAttribute fa2 = 0xFFFFFFFFUL;
CategoricalAttribute ch = 0xFFFFFFFFUL;
for (std::vector<CategoricalAttribute>::const_iterator it = order_loc.begin(); it != order_loc.end(); it++) {
double maxuncmi = -std::numeric_limits<double>::max();
if (waiting_nodes_loc[*it]) {
for (CategoricalAttribute xi = 0; xi < used_nodes_loc.size(); xi++) { //待选父节点
for (CategoricalAttribute xj = xi + 1; xj < used_nodes_loc.size(); xj++) {
if (maxuncmi < un_cmi_loc[*it][used_nodes_loc[xi]][used_nodes_loc[xj]]) {
maxuncmi = un_cmi_loc[*it][used_nodes_loc[xi]][used_nodes_loc[xj]];
fa1 = used_nodes_loc[xi];
fa2 = used_nodes_loc[xj];
ch = *it;
}
}
}
parents_1[ch].push_back(fa1);
parents_1[ch].push_back(fa2);
used_nodes_loc.push_back(ch);
waiting_nodes_loc[ch] = false;
}
}
}
std::vector<double> posteriorDist1;
posteriorDist1.assign(noClasses_, 0);
//联合概率
for (CatValue y = 0; y < noClasses_; y++) {
posteriorDist1[y] = classDist_.p(y) * (std::numeric_limits<double>::max() / 2.0);
}
for (unsigned int x1 = 0; x1 < noCatAtts_; x1++) {
for (CatValue y = 0; y < noClasses_; y++) {
if (parents_1[x1].size() == 0) {
posteriorDist1[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y); // p(a=v|Y=y) using M-estimate
} else if (parents_1[x1].size() == 1) {
const InstanceCount totalCount1 = dist_1.xxyCounts.xyCounts.getCount(parents_1[x1][0], inst.getCatVal(parents_1[x1][0]));
if (totalCount1 == 0) {
posteriorDist1[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y);
} else {
posteriorDist1[y] *= dist_1.xxyCounts.p(x1, inst.getCatVal(x1), parents_1[x1][0], inst.getCatVal(parents_1[x1][0]), y); // p(x1=v1|Y=y, x2=v2) using M-estimate
}
} else if (parents_1[x1].size() == 2) {
const InstanceCount totalCount1 = dist_1.xxyCounts.getCount(parents_1[x1][0], inst.getCatVal(parents_1[x1][0]), parents_1[x1][1], inst.getCatVal(parents_1[x1][1]));
if (totalCount1 == 0) {
const InstanceCount totalCount2 = dist_1.xxyCounts.xyCounts.getCount(parents_1[x1][0], inst.getCatVal(parents_1[x1][0]));
if (totalCount2 == 0) {
posteriorDist1[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y);
} else {
posteriorDist1[y] *= dist_1.xxyCounts.p(x1, inst.getCatVal(x1), parents_1[x1][0], inst.getCatVal(parents_1[x1][0]), y);
}
} else {
posteriorDist1[y] *= dist_1.p(x1, inst.getCatVal(x1), parents_1[x1][0], inst.getCatVal(parents_1[x1][0]), parents_1[x1][1], inst.getCatVal(parents_1[x1][1]), y);
}
}
}
}
// normalise the results
normalise(posteriorDist1);
//联合概率结合
for (int classno = 0; classno < noClasses_; classno++) {
posteriorDist[classno] += posteriorDist1[classno];
posteriorDist[classno] = posteriorDist[classno] / 2;
}
}
}
void sortkdb::getNoCatAtts_(unsigned int &NoCatAtt) {
//printf(" getNoCatAtts_ \n");
NoCatAtt = noCatAtts_;
}
void sortkdb::getStructure(std::vector<std::vector<CategoricalAttribute> > &parents, std::vector<CategoricalAttribute> &order) {
for (unsigned int i = 0; i < noCatAtts_; i++) {
for (unsigned int j = 0; j < parents_[i].size(); j++) {
parents[i].push_back(parents_[i][j]);
}
}
for (unsigned int i = 0; i < noCatAtts_; i++) {
order.push_back(order_[i]);
}
}
void sortkdb::classify_change(const instance& inst, std::vector<double> &posteriorDist, std::vector<std::vector<CategoricalAttribute> > &parents_) {
// calculate the class probabilities in parallel
// P(y)
for (CatValue y = 0; y < noClasses_; y++) {
posteriorDist[y] = classDist_.p(y) * (std::numeric_limits<double>::max() / 2.0);
}
for (unsigned int x1 = 0; x1 < noCatAtts_; x1++) {
for (CatValue y = 0; y < noClasses_; y++) {
if (parents_[x1].size() == 0) {
posteriorDist[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y); // p(a=v|Y=y) using M-estimate
} else if (parents_[x1].size() == 1) {
const InstanceCount totalCount1 = dist_1.xxyCounts.xyCounts.getCount(parents_[x1][0], inst.getCatVal(parents_[x1][0]));
if (totalCount1 == 0) {
posteriorDist[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y);
} else {
posteriorDist[y] *= dist_1.xxyCounts.p(x1, inst.getCatVal(x1), parents_[x1][0], inst.getCatVal(parents_[x1][0]), y); // p(x1=v1|Y=y, x2=v2) using M-estimate
}
} else if (parents_[x1].size() == 2) {
const InstanceCount totalCount1 = dist_1.xxyCounts.getCount(parents_[x1][0], inst.getCatVal(parents_[x1][0]), parents_[x1][1], inst.getCatVal(parents_[x1][1]));
if (totalCount1 == 0) {
const InstanceCount totalCount2 = dist_1.xxyCounts.xyCounts.getCount(parents_[x1][0], inst.getCatVal(parents_[x1][0]));
if (totalCount2 == 0) {
posteriorDist[y] *= dist_1.xxyCounts.xyCounts.p(x1, inst.getCatVal(x1), y);
} else {
posteriorDist[y] *= dist_1.xxyCounts.p(x1, inst.getCatVal(x1), parents_[x1][0], inst.getCatVal(parents_[x1][0]), y);
}
} else {
posteriorDist[y] *= dist_1.p(x1, inst.getCatVal(x1), parents_[x1][0], inst.getCatVal(parents_[x1][0]), parents_[x1][1], inst.getCatVal(parents_[x1][1]), y);
}
}
}
}
// normalise the results
normalise(posteriorDist);
//printf("have changed\n");
}
void sortkdb::chang_parents(std::vector<std::vector<CategoricalAttribute> > &parents_change) {
for (unsigned int i = 0; i < noCatAtts_; i++)
parents_[i].clear();
for (unsigned int i = 0; i < noCatAtts_; i++) {
for (unsigned int j = 0; j < parents_change[i].size(); j++) {
parents_[i].push_back(parents_change[i][j]);
}
}
}
| [
"Lirh_china@163.com"
] | Lirh_china@163.com |
c3b96f4f9cd33eb97be82c0ba9ca90ff59b46a56 | 25957c9f37187172a4f12a3540bfb6504b81a373 | /dynamicarray.h | 7f952468a617d64e91309877ca459e1d6c33a10e | [] | no_license | AlexDev328/Recipe | 7a17fabc934ca7d85137ab38ca3bba9ce0efd9a5 | 913f33b6b99a8b3c5d0ebccc86dbdad0df64a210 | refs/heads/master | 2020-03-29T10:07:06.983072 | 2018-09-21T16:39:45 | 2018-09-21T16:39:45 | 149,789,963 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 872 | h |
#include <iostream>
#include <conio.h>
template<class T>
class DynamicArray {
long size; //size of the array
long count; //count of elements
T* p; //pointer to the beginning of the array
public:
//constructors
DynamicArray(long s = 10): size(s), count(0) {
p = new T[size];
}
DynamicArray(const DynamicArray& arr);
//destructor
~DynamicArray() {
if(p) delete[] p;
}
//member functions
void add(T x);
void add(T x,int index);
void addwithsort(T x);
void remove();
long length() const {return size;}
long getCount() const {return count;}
void print() const;
//operators
DynamicArray& operator=(const DynamicArray& arr);
T operator [] (long i) const;
DynamicArray& operator+(const DynamicArray& arr);
};
| [
"noreply@github.com"
] | noreply@github.com |
0f68aa664bb8898342d56d2b7e6be926d1d9a4d4 | 0034c069d5815c71c4252ff7cb4e755712425eaf | /deps/include/weibo/protobuf/io/tokenizer.h | 8b7a4b271bdab82869e3c933555ba5276c449967 | [
"Apache-2.0"
] | permissive | niuchenglei/rankextor | 3f3c912cf0c872509a35a67ebd4c636b080003e1 | 342e39dda8347b0986f6d2be9968ee72a90b16c2 | refs/heads/master | 2020-12-03T11:34:17.113500 | 2020-01-02T03:29:20 | 2020-01-02T03:29:20 | 231,300,419 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 12,864 | h | // Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.weibo.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * 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.
// * Neither the name of Google Inc. 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
// OWNER 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.
// Author: kenton@weibo.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// Class for parsing tokenized text from a ZeroCopyInputStream.
#ifndef GOOGLE_PROTOBUF_IO_TOKENIZER_H__
#define GOOGLE_PROTOBUF_IO_TOKENIZER_H__
#include <string>
#include <weibo/protobuf/stubs/common.h>
namespace weibo {
namespace protobuf {
namespace io {
class ZeroCopyInputStream; // zero_copy_stream.h
// Defined in this file.
class ErrorCollector;
class Tokenizer;
// Abstract interface for an object which collects the errors that occur
// during parsing. A typical implementation might simply print the errors
// to stdout.
class LIBPROTOBUF_EXPORT ErrorCollector {
public:
inline ErrorCollector() {}
virtual ~ErrorCollector();
// Indicates that there was an error in the input at the given line and
// column numbers. The numbers are zero-based, so you may want to add
// 1 to each before printing them.
virtual void AddError(int line, int column, const string& message) = 0;
// Indicates that there was a warning in the input at the given line and
// column numbers. The numbers are zero-based, so you may want to add
// 1 to each before printing them.
virtual void AddWarning(int line, int column, const string& message) { }
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
};
// This class converts a stream of raw text into a stream of tokens for
// the protocol definition parser to parse. The tokens recognized are
// similar to those that make up the C language; see the TokenType enum for
// precise descriptions. Whitespace and comments are skipped. By default,
// C- and C++-style comments are recognized, but other styles can be used by
// calling set_comment_style().
class LIBPROTOBUF_EXPORT Tokenizer {
public:
// Construct a Tokenizer that reads and tokenizes text from the given
// input stream and writes errors to the given error_collector.
// The caller keeps ownership of input and error_collector.
Tokenizer(ZeroCopyInputStream* input, ErrorCollector* error_collector);
~Tokenizer();
enum TokenType {
TYPE_START, // Next() has not yet been called.
TYPE_END, // End of input reached. "text" is empty.
TYPE_IDENTIFIER, // A sequence of letters, digits, and underscores, not
// starting with a digit. It is an error for a number
// to be followed by an identifier with no space in
// between.
TYPE_INTEGER, // A sequence of digits representing an integer. Normally
// the digits are decimal, but a prefix of "0x" indicates
// a hex number and a leading zero indicates octal, just
// like with C numeric literals. A leading negative sign
// is NOT included in the token; it's up to the parser to
// interpret the unary minus operator on its own.
TYPE_FLOAT, // A floating point literal, with a fractional part and/or
// an exponent. Always in decimal. Again, never
// negative.
TYPE_STRING, // A quoted sequence of escaped characters. Either single
// or double quotes can be used, but they must match.
// A string literal cannot cross a line break.
TYPE_SYMBOL, // Any other printable character, like '!' or '+'.
// Symbols are always a single character, so "!+$%" is
// four tokens.
};
// Structure representing a token read from the token stream.
struct Token {
TokenType type;
string text; // The exact text of the token as it appeared in
// the input. e.g. tokens of TYPE_STRING will still
// be escaped and in quotes.
// "line" and "column" specify the position of the first character of
// the token within the input stream. They are zero-based.
int line;
int column;
int end_column;
};
// Get the current token. This is updated when Next() is called. Before
// the first call to Next(), current() has type TYPE_START and no contents.
const Token& current();
// Return the previous token -- i.e. what current() returned before the
// previous call to Next().
const Token& previous();
// Advance to the next token. Returns false if the end of the input is
// reached.
bool Next();
// Parse helpers ---------------------------------------------------
// Parses a TYPE_FLOAT token. This never fails, so long as the text actually
// comes from a TYPE_FLOAT token parsed by Tokenizer. If it doesn't, the
// result is undefined (possibly an assert failure).
static double ParseFloat(const string& text);
// Parses a TYPE_STRING token. This never fails, so long as the text actually
// comes from a TYPE_STRING token parsed by Tokenizer. If it doesn't, the
// result is undefined (possibly an assert failure).
static void ParseString(const string& text, string* output);
// Identical to ParseString, but appends to output.
static void ParseStringAppend(const string& text, string* output);
// Parses a TYPE_INTEGER token. Returns false if the result would be
// greater than max_value. Otherwise, returns true and sets *output to the
// result. If the text is not from a Token of type TYPE_INTEGER originally
// parsed by a Tokenizer, the result is undefined (possibly an assert
// failure).
static bool ParseInteger(const string& text, uint64 max_value,
uint64* output);
// Options ---------------------------------------------------------
// Set true to allow floats to be suffixed with the letter 'f'. Tokens
// which would otherwise be integers but which have the 'f' suffix will be
// forced to be interpreted as floats. For all other purposes, the 'f' is
// ignored.
void set_allow_f_after_float(bool value) { allow_f_after_float_ = value; }
// Valid values for set_comment_style().
enum CommentStyle {
// Line comments begin with "//", block comments are delimited by "/*" and
// "*/".
CPP_COMMENT_STYLE,
// Line comments begin with "#". No way to write block comments.
SH_COMMENT_STYLE
};
// Sets the comment style.
void set_comment_style(CommentStyle style) { comment_style_ = style; }
// -----------------------------------------------------------------
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Tokenizer);
Token current_; // Returned by current().
Token previous_; // Returned by previous().
ZeroCopyInputStream* input_;
ErrorCollector* error_collector_;
char current_char_; // == buffer_[buffer_pos_], updated by NextChar().
const char* buffer_; // Current buffer returned from input_.
int buffer_size_; // Size of buffer_.
int buffer_pos_; // Current position within the buffer.
bool read_error_; // Did we previously encounter a read error?
// Line and column number of current_char_ within the whole input stream.
int line_;
int column_;
// Position in buffer_ where StartToken() was called. If the token
// started in the previous buffer, this is zero, and current_.text already
// contains the part of the token from the previous buffer. If not
// currently parsing a token, this is -1.
int token_start_;
// Options.
bool allow_f_after_float_;
CommentStyle comment_style_;
// Since we count columns we need to interpret tabs somehow. We'll take
// the standard 8-character definition for lack of any way to do better.
static const int kTabWidth = 8;
// -----------------------------------------------------------------
// Helper methods.
// Consume this character and advance to the next one.
void NextChar();
// Read a new buffer from the input.
void Refresh();
// Called when the current character is the first character of a new
// token (not including whitespace or comments).
inline void StartToken();
// Called when the current character is the first character after the
// end of the last token. After this returns, current_.text will
// contain all text consumed since StartToken() was called.
inline void EndToken();
// Convenience method to add an error at the current line and column.
void AddError(const string& message) {
error_collector_->AddError(line_, column_, message);
}
// -----------------------------------------------------------------
// The following four methods are used to consume tokens of specific
// types. They are actually used to consume all characters *after*
// the first, since the calling function consumes the first character
// in order to decide what kind of token is being read.
// Read and consume a string, ending when the given delimiter is
// consumed.
void ConsumeString(char delimiter);
// Read and consume a number, returning TYPE_FLOAT or TYPE_INTEGER
// depending on what was read. This needs to know if the first
// character was a zero in order to correctly recognize hex and octal
// numbers.
// It also needs to know if the first characted was a . to parse floating
// point correctly.
TokenType ConsumeNumber(bool started_with_zero, bool started_with_dot);
// Consume the rest of a line.
void ConsumeLineComment();
// Consume until "*/".
void ConsumeBlockComment();
// -----------------------------------------------------------------
// These helper methods make the parsing code more readable. The
// "character classes" refered to are defined at the top of the .cc file.
// Basically it is a C++ class with one method:
// static bool InClass(char c);
// The method returns true if c is a member of this "class", like "Letter"
// or "Digit".
// Returns true if the current character is of the given character
// class, but does not consume anything.
template<typename CharacterClass>
inline bool LookingAt();
// If the current character is in the given class, consume it and return
// true. Otherwise return false.
// e.g. TryConsumeOne<Letter>()
template<typename CharacterClass>
inline bool TryConsumeOne();
// Like above, but try to consume the specific character indicated.
inline bool TryConsume(char c);
// Consume zero or more of the given character class.
template<typename CharacterClass>
inline void ConsumeZeroOrMore();
// Consume one or more of the given character class or log the given
// error message.
// e.g. ConsumeOneOrMore<Digit>("Expected digits.");
template<typename CharacterClass>
inline void ConsumeOneOrMore(const char* error);
};
// inline methods ====================================================
inline const Tokenizer::Token& Tokenizer::current() {
return current_;
}
inline const Tokenizer::Token& Tokenizer::previous() {
return previous_;
}
inline void Tokenizer::ParseString(const string& text, string* output) {
output->clear();
ParseStringAppend(text, output);
}
} // namespace io
} // namespace protobuf
} // namespace weibo
#endif // GOOGLE_PROTOBUF_IO_TOKENIZER_H__
| [
"chenglei3@staff.weibo.com"
] | chenglei3@staff.weibo.com |
76af3b1e054480dc1edf4a82c4ec7b8d4a83a218 | 1385c32207e378f47bf2153956825e89228b8de1 | /source/hpp/Win32/tokyo/ALFmxDesignEditors.hpp | b7a745e65655adabcc636b893bada04787fcd305 | [
"Apache-2.0",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-free-unknown"
] | permissive | marlonnardi/alcinoe | 4d5dc32328fff661792f5805a799e16b001688d1 | 5e14b2fca7adcc38e483771055b5623501433334 | refs/heads/master | 2020-08-12T09:38:29.484894 | 2020-05-17T23:17:32 | 2020-05-17T23:17:32 | 163,667,647 | 1 | 0 | Apache-2.0 | 2019-10-12T22:52:31 | 2018-12-31T12:34:34 | Pascal | UTF-8 | C++ | false | false | 6,402 | hpp | // CodeGear C++Builder
// Copyright (c) 1995, 2017 by Embarcadero Technologies, Inc.
// All rights reserved
// (DO NOT EDIT: machine generated header) 'ALFmxDesignEditors.pas' rev: 32.00 (Windows)
#ifndef AlfmxdesigneditorsHPP
#define AlfmxdesigneditorsHPP
#pragma delphiheader begin
#pragma option push
#pragma option -w- // All warnings off
#pragma option -Vx // Zero-length empty class member
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>
#include <System.Classes.hpp>
#include <System.Generics.Collections.hpp>
#include <FMX.Types.hpp>
#include <DesignIntf.hpp>
#include <DesignEditors.hpp>
#include <DesignMenus.hpp>
#include <System.SysUtils.hpp>
#include <System.Generics.Defaults.hpp>
//-- user supplied -----------------------------------------------------------
namespace Alfmxdesigneditors
{
//-- forward type declarations -----------------------------------------------
struct TALItemClassDesc;
class DELPHICLASS TALItemsEditor;
class DELPHICLASS TALTabControlEditor;
class DELPHICLASS TALTabItemEditor;
//-- type declarations -------------------------------------------------------
struct DECLSPEC_DRECORD TALItemClassDesc
{
public:
Fmx::Types::TFmxObjectClass ItemClass;
bool CanContainSimilarItem;
bool ShowOnlyInMenu;
__fastcall TALItemClassDesc(const Fmx::Types::TFmxObjectClass AItemClass, const bool ACanContaineSimilarItem, const bool AShowOnlyInMenu);
TALItemClassDesc() {}
};
#pragma pack(push,4)
class PASCALIMPLEMENTATION TALItemsEditor : public Designeditors::TComponentEditor
{
typedef Designeditors::TComponentEditor inherited;
private:
typedef System::DynamicArray<TALItemClassDesc> _TALItemsEditor__1;
private:
static System::Generics::Collections::TDictionary__2<System::UnicodeString,int>* FListOfLastItems;
protected:
bool FAllowChild;
_TALItemsEditor__1 FItemsClasses;
virtual void __fastcall DoCreateItem(System::TObject* Sender);
int __fastcall GetIndexOfItemClass(void);
void __fastcall SetIndexOfItemClass(const int Value);
virtual bool __fastcall CanShow(void);
__property int IndexOfItemClass = {read=GetIndexOfItemClass, write=SetIndexOfItemClass, nodefault};
public:
virtual void __fastcall ExecuteVerb(int Index);
virtual System::UnicodeString __fastcall GetVerb(int Index);
virtual int __fastcall GetVerbCount(void);
virtual void __fastcall PrepareItem(int Index, const Designmenus::_di_IMenuItem AItem);
public:
/* TComponentEditor.Create */ inline __fastcall virtual TALItemsEditor(System::Classes::TComponent* AComponent, Designintf::_di_IDesigner ADesigner) : Designeditors::TComponentEditor(AComponent, ADesigner) { }
public:
/* TObject.Destroy */ inline __fastcall virtual ~TALItemsEditor(void) { }
};
#pragma pack(pop)
#pragma pack(push,4)
class PASCALIMPLEMENTATION TALTabControlEditor : public TALItemsEditor
{
typedef TALItemsEditor inherited;
private:
int FEditorNextTab;
int FEditorPrevTab;
int FEditorDeleteTab;
int FVerbCount;
int __fastcall GetTabIndex(void);
protected:
virtual void __fastcall DoCreateItem(System::TObject* Sender);
public:
__fastcall virtual TALTabControlEditor(System::Classes::TComponent* AComponent, Designintf::_di_IDesigner ADesigner);
virtual void __fastcall ExecuteVerb(int Index);
virtual System::UnicodeString __fastcall GetVerb(int Index);
virtual int __fastcall GetVerbCount(void);
virtual void __fastcall PrepareItem(int Index, const Designmenus::_di_IMenuItem AItem);
public:
/* TObject.Destroy */ inline __fastcall virtual ~TALTabControlEditor(void) { }
};
#pragma pack(pop)
#pragma pack(push,4)
class PASCALIMPLEMENTATION TALTabItemEditor : public Designeditors::TComponentEditor
{
typedef Designeditors::TComponentEditor inherited;
public:
virtual void __fastcall ExecuteVerb(int Index);
virtual System::UnicodeString __fastcall GetVerb(int Index);
virtual int __fastcall GetVerbCount(void);
virtual void __fastcall PrepareItem(int Index, const Designmenus::_di_IMenuItem AItem);
public:
/* TComponentEditor.Create */ inline __fastcall virtual TALTabItemEditor(System::Classes::TComponent* AComponent, Designintf::_di_IDesigner ADesigner) : Designeditors::TComponentEditor(AComponent, ADesigner) { }
public:
/* TObject.Destroy */ inline __fastcall virtual ~TALTabItemEditor(void) { }
};
#pragma pack(pop)
//-- var, const, procedure ---------------------------------------------------
extern DELPHI_PACKAGE System::ResourceString _SNewItem;
#define Alfmxdesigneditors_SNewItem System::LoadResourceString(&Alfmxdesigneditors::_SNewItem)
extern DELPHI_PACKAGE System::ResourceString _SNewLastItem;
#define Alfmxdesigneditors_SNewLastItem System::LoadResourceString(&Alfmxdesigneditors::_SNewLastItem)
extern DELPHI_PACKAGE System::ResourceString _SItems;
#define Alfmxdesigneditors_SItems System::LoadResourceString(&Alfmxdesigneditors::_SItems)
extern DELPHI_PACKAGE System::ResourceString _SNextTab;
#define Alfmxdesigneditors_SNextTab System::LoadResourceString(&Alfmxdesigneditors::_SNextTab)
extern DELPHI_PACKAGE System::ResourceString _SPrevTab;
#define Alfmxdesigneditors_SPrevTab System::LoadResourceString(&Alfmxdesigneditors::_SPrevTab)
extern DELPHI_PACKAGE System::ResourceString _SUnnamedTab;
#define Alfmxdesigneditors_SUnnamedTab System::LoadResourceString(&Alfmxdesigneditors::_SUnnamedTab)
extern DELPHI_PACKAGE System::ResourceString _SDeleteItem;
#define Alfmxdesigneditors_SDeleteItem System::LoadResourceString(&Alfmxdesigneditors::_SDeleteItem)
extern DELPHI_PACKAGE System::ResourceString _SSetActive;
#define Alfmxdesigneditors_SSetActive System::LoadResourceString(&Alfmxdesigneditors::_SSetActive)
static const System::Int8 EDITOR_CREATE_ITEM = System::Int8(0x0);
static const System::Int8 EDITOR_NEW_ITEM = System::Int8(0x1);
static const System::Int8 EDITOR_SET_ACTIVE = System::Int8(0x0);
extern DELPHI_PACKAGE void __fastcall Register(void);
} /* namespace Alfmxdesigneditors */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_ALFMXDESIGNEDITORS)
using namespace Alfmxdesigneditors;
#endif
#pragma pack(pop)
#pragma option pop
#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif // AlfmxdesigneditorsHPP
| [
"4325047+Zeus5100@users.noreply.github.com"
] | 4325047+Zeus5100@users.noreply.github.com |
0af1159276e7fd0ba525c2a31cae78014ac0b141 | df0460a764643a4fb241a2db946738af6289399a | /Plugins/MatchmakingServer/Source/Matchmaking/Public/MatchmakingGameModeBase.h | 39c66039a1519384e11fbed3cfce572260d8356d | [] | no_license | Skellycrude/React-Racing-server | 2267910194df92393c25f37f49fad4d45e574cd0 | 7cabb376fc74d59227e5ee931a9a7ed15ae57a27 | refs/heads/master | 2021-10-10T22:42:12.415291 | 2019-01-18T13:22:09 | 2019-01-18T13:22:09 | 148,512,107 | 1 | 0 | null | 2018-12-13T20:22:43 | 2018-09-12T16:49:12 | C++ | UTF-8 | C++ | false | false | 756 | h | // Copyright 2017-2018 Robin Zinser. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Engine.h"
#include "GameFramework/GameMode.h"
#include "MatchmakingGameModeBase.generated.h"
/**
*
*/
UCLASS()
class MATCHMAKING_API AMatchmakingGameModeBase : public AGameMode
{
GENERATED_BODY()
virtual FString InitNewPlayer(APlayerController* NewPlayerController, const FUniqueNetIdRepl& UniqueId, const FString& Options, const FString& Portal = TEXT("")) override;
public:
UFUNCTION(BlueprintImplementableEvent, Category = "Matchmaking")
void Server_LoginClient(APlayerController* NewPlayerController, const FString& Client_Name, const FString& Char_Name, const FString& Char_ID, const FString& Team, const FString& FullParameters);
};
| [
"andrewmedved@gmail.com"
] | andrewmedved@gmail.com |
dbb6da5e5c337b69d5df7e2c3c8569d53b264cff | 87d1f9d88a204b2cf7748491aa4b10c909984966 | /src/instruments/buttons/Button.cpp | 58238f9dbdc6d2da65ec9740f36df761e23f6831 | [] | no_license | yaroslav-tarasov/OpenEaagles | 2c9e683cdf9d191c07daf53e444a7aabb487dfcb | 8551df88bebab03a6cdaed8649cfed91d7f4ad19 | refs/heads/master | 2021-01-17T06:33:29.753917 | 2015-04-06T18:23:15 | 2015-04-06T18:23:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,808 | cpp | #include "openeaagles/instruments/buttons/Button.h"
#include "openeaagles/basic/Number.h"
#include "openeaagles/basicGL/Display.h"
namespace Eaagles {
namespace Instruments {
IMPLEMENT_SUBCLASS(Button,"Button")
EMPTY_SERIALIZER(Button)
//------------------------------------------------------------------------------
// Slot table for this form type
//------------------------------------------------------------------------------
BEGIN_SLOTTABLE(Button)
"eventId", // Which event we will send for each button (A, B, C events)
END_SLOTTABLE(Button)
//------------------------------------------------------------------------------
// Map slot table to handles
//------------------------------------------------------------------------------
BEGIN_SLOT_MAP(Button)
ON_SLOT(1, setSlotEventId, Basic::Number)
END_SLOT_MAP()
//------------------------------------------------------------------------------
// Event Table
//------------------------------------------------------------------------------
BEGIN_EVENT_HANDLER(Button)
ON_EVENT(ON_SINGLE_CLICK, onSingleClick)
ON_EVENT(ON_CANCEL, onCancel)
END_EVENT_HANDLER()
//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
Button::Button()
{
STANDARD_CONSTRUCTOR()
eventId = -1;
}
//------------------------------------------------------------------------------
// copyData() -- copy this object's data
//------------------------------------------------------------------------------
void Button::copyData(const Button& org, const bool)
{
BaseClass::copyData(org);
eventId = org.eventId;
}
//------------------------------------------------------------------------------
// deleteData() -- delete this object's data
//------------------------------------------------------------------------------
EMPTY_DELETEDATA(Button)
//------------------------------------------------------------------------------
// setSlotEventId() - sets our slot event Id
//------------------------------------------------------------------------------
bool Button::setSlotEventId(const Basic::Number* const newEvent)
{
bool ok = false;
if (newEvent != 0) {
int a = newEvent->getInt();
ok = setEventId(a);
}
return ok;
}
//------------------------------------------------------------------------------
// onSingleClick() - tells us we have been clicked, and we can override this
// to make it do whatever we want.
//------------------------------------------------------------------------------
bool Button::onSingleClick()
{
// when I am clicked, I will send an event to my container, we find out what
// event Id we have, and send that eventId
bool ok = false;
BasicGL::Display* myDisplay = (BasicGL::Display*)findContainerByType(typeid(BasicGL::Display));
if (myDisplay != 0) {
myDisplay->buttonEvent(getEventId());
ok = true;
}
return ok;
}
//------------------------------------------------------------------------------
// onCancel() - this is where we cancel button pushes
//------------------------------------------------------------------------------
bool Button::onCancel()
{
// do nothing here, but our pushbuttons and switches will!
return true;
}
//------------------------------------------------------------------------------
// getSlotByIndex() for Button
//------------------------------------------------------------------------------
Basic::Object* Button::getSlotByIndex(const int si)
{
return BaseClass::getSlotByIndex(si);
}
} // end Instruments namespace
} // end Eaagles namespace
| [
"doug@openeaagles.org"
] | doug@openeaagles.org |
7e249e9f8aaff583517a18267738c547d842a6aa | c96c82e9109dba6d7184fbcf01eba8a0c36b6726 | /ui/model/messages.cpp | 282cd1f898a3e815a4e8235c99db90d1461a3f3b | [
"Apache-2.0"
] | permissive | 1M15M3/beam | d2ae507ff7438eb734e898a014b6cca548b6757e | 9c0a93488f3ba6dab6e716750d76c5257ef2e5b2 | refs/heads/master | 2020-04-17T18:43:13.782842 | 2019-01-21T13:50:38 | 2019-01-21T13:51:15 | 166,838,589 | 1 | 0 | Apache-2.0 | 2019-01-21T15:41:39 | 2019-01-21T15:41:39 | null | UTF-8 | C++ | false | false | 796 | cpp | // Copyright 2018 The Beam Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "messages.h"
#include <QtQuick>
using namespace std;
MessageManager::MessageManager()
{
}
void MessageManager::addMessage(const QString& message)
{
emit newMessage(message);
} | [
"sevoatysnaa@gmail.com"
] | sevoatysnaa@gmail.com |
612364ce7ef801385121035d5369a0c522d998e6 | 6b43be4b05898606cfd4744e52b6a6819e5d4596 | /core/src/Mathematics/Matrix.hpp | ac02dc081fb7ea1110ca6629be4c5a63bd338745 | [
"BSD-3-Clause"
] | permissive | kiran1228/crimild | b5fff6877f6a2acd28ee8c019b818c92d5a4754a | ad72af4f96d532885cf4afc39717f185e94d9ee9 | refs/heads/master | 2020-03-21T16:50:52.245176 | 2018-06-01T16:26:42 | 2018-06-01T16:26:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,974 | hpp | /*
* Copyright (c) 2013, Hernan Saez
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the <organization> 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 <COPYRIGHT HOLDER> 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.
*/
#ifndef CRIMILD_CORE_MATHEMATICS_MATRIX_
#define CRIMILD_CORE_MATHEMATICS_MATRIX_
#include "Vector.hpp"
#include "Numeric.hpp"
namespace crimild {
/**
\brief A geometric matrix
*/
template< crimild::Size SIZE, typename PRECISION >
class Matrix {
public:
Matrix( void )
{
}
explicit Matrix( const PRECISION *data )
{
memcpy( _data, data, sizeof( PRECISION ) * SIZE * SIZE );
}
Matrix( const Matrix &u )
{
memcpy( _data, u._data, sizeof( PRECISION ) * SIZE * SIZE );
}
Matrix( const Vector< SIZE, PRECISION > &axis, PRECISION angle )
{
fromAxisAngle( axis, angle );
}
Matrix( PRECISION a00, PRECISION a01,
PRECISION a10, PRECISION a11 )
{
_data[ 0 ] = a00;
_data[ 1 ] = a01;
_data[ 2 ] = a10;
_data[ 3 ] = a11;
}
Matrix( PRECISION a00, PRECISION a01, PRECISION a02,
PRECISION a10, PRECISION a11, PRECISION a12,
PRECISION a20, PRECISION a21, PRECISION a22 )
{
_data[ 0 ] = a00;
_data[ 1 ] = a01;
_data[ 2 ] = a02;
_data[ 3 ] = a10;
_data[ 4 ] = a11;
_data[ 5 ] = a12;
_data[ 6 ] = a20;
_data[ 7 ] = a21;
_data[ 8 ] = a22;
}
Matrix( PRECISION a00, PRECISION a01, PRECISION a02, PRECISION a03,
PRECISION a10, PRECISION a11, PRECISION a12, PRECISION a13,
PRECISION a20, PRECISION a21, PRECISION a22, PRECISION a23,
PRECISION a30, PRECISION a31, PRECISION a32, PRECISION a33 )
{
_data[ 0 ] = a00;
_data[ 1 ] = a01;
_data[ 2 ] = a02;
_data[ 3 ] = a03;
_data[ 4 ] = a10;
_data[ 5 ] = a11;
_data[ 6 ] = a12;
_data[ 7 ] = a13;
_data[ 8 ] = a20;
_data[ 9 ] = a21;
_data[ 10 ] = a22;
_data[ 11 ] = a23;
_data[ 12 ] = a30;
_data[ 13 ] = a31;
_data[ 14 ] = a32;
_data[ 15 ] = a33;
}
~Matrix( void )
{
}
Matrix &operator=( const Matrix &u )
{
memcpy( _data, u._data, sizeof( PRECISION ) * SIZE * SIZE );
return *this;
}
PRECISION operator[]( int i ) const
{
return _data[ i ];
}
PRECISION &operator[]( int i )
{
return _data[ i ];
}
// explicit conversion
explicit operator PRECISION *(void) { return &_data[0]; }
explicit operator const PRECISION *(void) const { return &_data[0]; }
PRECISION *data( void ) { return _data; }
const PRECISION *getData( void ) const { return _data; }
bool operator==( const Matrix &u ) const
{
if ( SIZE == 3 ) {
return ( Numeric< PRECISION >::equals( _data[ 0 ], u._data[ 0 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 1 ], u._data[ 1 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 2 ], u._data[ 2 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 3 ], u._data[ 3 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 4 ], u._data[ 4 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 5 ], u._data[ 5 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 6 ], u._data[ 6 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 7 ], u._data[ 7 ] ) );
}
else if ( SIZE == 2 ) {
return ( Numeric< PRECISION >::equals( _data[ 0 ], u._data[ 0 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 1 ], u._data[ 1 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 2 ], u._data[ 2 ] ) ) &&
( Numeric< PRECISION >::equals( _data[ 3 ], u._data[ 3 ] ) );
}
else {
bool areEqual = true;
for ( crimild::Size i = 0; i < SIZE * SIZE; i++ ) {
areEqual &= Numeric< PRECISION >::equals( _data[ i ], u._data[ i ] );
}
return areEqual;
}
}
bool operator!=( const Matrix &u )
{
return ( memcmp( _data, u._data, sizeof( PRECISION ) * SIZE * SIZE ) != 0 );
}
Matrix &makeIdentity( void )
{
if ( SIZE == 3 ) {
_data[ 0 ] = 1;
_data[ 1 ] = 0;
_data[ 2 ] = 0;
_data[ 3 ] = 0;
_data[ 4 ] = 1;
_data[ 5 ] = 0;
_data[ 6 ] = 0;
_data[ 7 ] = 0;
_data[ 8 ] = 1;
}
else if ( SIZE == 2 ) {
_data[ 0 ] = 1;
_data[ 1 ] = 0;
_data[ 2 ] = 0;
_data[ 3 ] = 1;
}
else {
for ( crimild::Size i = 0; i < SIZE; i++ ) {
for ( crimild::Size j = 0; j < SIZE; j++ ) {
if ( i == j ) {
_data[ i * SIZE + j ] = 1;
}
else {
_data[ i * SIZE + j ] = 0;
}
}
}
}
return *this;
}
Matrix getTranspose( void ) const
{
Matrix result;
if ( SIZE == 3 ) {
result._data[ 0 ] = _data[ 0 ];
result._data[ 1 ] = _data[ 3 ];
result._data[ 2 ] = _data[ 6 ];
result._data[ 3 ] = _data[ 1 ];
result._data[ 4 ] = _data[ 4 ];
result._data[ 5 ] = _data[ 7 ];
result._data[ 6 ] = _data[ 2 ];
result._data[ 7 ] = _data[ 5 ];
result._data[ 8 ] = _data[ 8 ];
}
else if ( SIZE == 2 ) {
result._data[ 0 ] = _data[ 0 ];
result._data[ 1 ] = _data[ 2 ];
result._data[ 2 ] = _data[ 1 ];
result._data[ 3 ] = _data[ 3 ];
}
else {
for ( crimild::Size i = 0; i < SIZE; i++ ) {
for ( crimild::Size j = 0; j < SIZE; j++ ) {
result._data[ j * SIZE + i ] = _data[ i * SIZE + j ];
}
}
}
return result;
}
Matrix &makeTranspose( void )
{
*this = getTranspose();
return *this;
}
double getDeterminant( void ) const
{
double result = 1.0;
if ( SIZE == 3 ) {
result = _data[ 0 ] * ( _data[ 4 ] * _data[ 8 ] - _data[ 5 ] * _data[ 7 ] )
- _data[ 1 ] * ( _data[ 3 ] * _data[ 8 ] - _data[ 5 ] * _data[ 6 ] )
+ _data[ 2 ] * ( _data[ 3 ] * _data[ 7 ] - _data[ 4 ] * _data[ 6 ] );
}
else if ( SIZE == 2 ) {
result = _data[ 0 ] * _data[ 3 ] - _data[ 1 ] * _data[ 2 ];
}
else if ( SIZE == 4 ) {
PRECISION a00 = _data[ 0 ], a01 = _data[ 1 ], a02 = _data[ 2 ], a03 = _data[ 3 ],
a10 = _data[ 4 ], a11 = _data[ 5 ], a12 = _data[ 6 ], a13 = _data[ 7 ],
a20 = _data[ 8 ], a21 = _data[ 9 ], a22 = _data[ 10 ], a23 = _data[ 11 ],
a30 = _data[ 12 ], a31 = _data[ 13 ], a32 = _data[ 14 ], a33 = _data[ 15 ];
PRECISION b00 = a00 * a11 - a01 * a10;
PRECISION b01 = a00 * a12 - a02 * a10;
PRECISION b02 = a00 * a13 - a03 * a10;
PRECISION b03 = a01 * a12 - a02 * a11;
PRECISION b04 = a01 * a13 - a03 * a11;
PRECISION b05 = a02 * a13 - a03 * a12;
PRECISION b06 = a20 * a31 - a21 * a30;
PRECISION b07 = a20 * a32 - a22 * a30;
PRECISION b08 = a20 * a33 - a23 * a30;
PRECISION b09 = a21 * a32 - a22 * a31;
PRECISION b10 = a21 * a33 - a23 * a31;
PRECISION b11 = a22 * a33 - a23 * a32;
result = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
}
return result;
}
bool isInvertible( void ) const
{
return getDeterminant() != 0;
}
Matrix getInverse( void ) const
{
double d = getDeterminant();
assert( d != 0 );
double invDet = static_cast< double >( 1.0 ) / static_cast< double >( d );
Matrix result;
if ( SIZE == 3 ) {
result._data[ 0 ] = ( _data[ 4 ] * _data[ 8 ] - _data[ 5 ] * _data[ 7 ] ) * invDet;
result._data[ 1 ] = ( _data[ 2 ] * _data[ 7 ] - _data[ 1 ] * _data[ 8 ] ) * invDet;
result._data[ 2 ] = ( _data[ 1 ] * _data[ 5 ] - _data[ 2 ] * _data[ 4 ] ) * invDet;
result._data[ 3 ] = ( _data[ 5 ] * _data[ 6 ] - _data[ 3 ] * _data[ 8 ] ) * invDet;
result._data[ 4 ] = ( _data[ 0 ] * _data[ 8 ] - _data[ 2 ] * _data[ 6 ] ) * invDet;
result._data[ 5 ] = ( _data[ 2 ] * _data[ 3 ] - _data[ 0 ] * _data[ 5 ] ) * invDet;
result._data[ 6 ] = ( _data[ 3 ] * _data[ 7 ] - _data[ 4 ] * _data[ 6 ] ) * invDet;
result._data[ 7 ] = ( _data[ 1 ] * _data[ 6 ] - _data[ 0 ] * _data[ 7 ] ) * invDet;
result._data[ 8 ] = ( _data[ 0 ] * _data[ 4 ] - _data[ 1 ] * _data[ 3 ] ) * invDet;
}
else if ( SIZE == 4 ) {
PRECISION a00 = _data[ 0 ], a01 = _data[ 1 ], a02 = _data[ 2 ], a03 = _data[ 3 ],
a10 = _data[ 4 ], a11 = _data[ 5 ], a12 = _data[ 6 ], a13 = _data[ 7 ],
a20 = _data[ 8 ], a21 = _data[ 9 ], a22 = _data[ 10 ], a23 = _data[ 11 ],
a30 = _data[ 12 ], a31 = _data[ 13 ], a32 = _data[ 14 ], a33 = _data[ 15 ];
PRECISION b00 = a00 * a11 - a01 * a10;
PRECISION b01 = a00 * a12 - a02 * a10;
PRECISION b02 = a00 * a13 - a03 * a10;
PRECISION b03 = a01 * a12 - a02 * a11;
PRECISION b04 = a01 * a13 - a03 * a11;
PRECISION b05 = a02 * a13 - a03 * a12;
PRECISION b06 = a20 * a31 - a21 * a30;
PRECISION b07 = a20 * a32 - a22 * a30;
PRECISION b08 = a20 * a33 - a23 * a30;
PRECISION b09 = a21 * a32 - a22 * a31;
PRECISION b10 = a21 * a33 - a23 * a31;
PRECISION b11 = a22 * a33 - a23 * a32;
PRECISION det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
assert( det != 0 );
PRECISION invDet = 1.0 / det;
result._data[ 0 ] = ( a11 * b11 - a12 * b10 + a13 * b09 ) * invDet;
result._data[ 1 ] = ( a02 * b10 - a01 * b11 - a03 * b09 ) * invDet;
result._data[ 2 ] = ( a31 * b05 - a32 * b04 + a33 * b03 ) * invDet;
result._data[ 3 ] = ( a22 * b04 - a21 * b05 - a23 * b03 ) * invDet;
result._data[ 4 ] = ( a12 * b08 - a10 * b11 - a13 * b07 ) * invDet;
result._data[ 5 ] = ( a00 * b11 - a02 * b08 + a03 * b07 ) * invDet;
result._data[ 6 ] = ( a32 * b02 - a30 * b05 - a33 * b01 ) * invDet;
result._data[ 7 ] = ( a20 * b05 - a22 * b02 + a23 * b01 ) * invDet;
result._data[ 8 ] = ( a10 * b10 - a11 * b08 + a13 * b06 ) * invDet;
result._data[ 9 ] = ( a01 * b08 - a00 * b10 - a03 * b06 ) * invDet;
result._data[ 10 ] = ( a30 * b04 - a31 * b02 + a33 * b00 ) * invDet;
result._data[ 11 ] = ( a21 * b02 - a20 * b04 - a23 * b00 ) * invDet;
result._data[ 12 ] = ( a11 * b07 - a10 * b09 - a12 * b06 ) * invDet;
result._data[ 13 ] = ( a00 * b09 - a01 * b07 + a02 * b06 ) * invDet;
result._data[ 14 ] = ( a31 * b01 - a30 * b03 - a32 * b00 ) * invDet;
result._data[ 15 ] = ( a20 * b03 - a21 * b01 + a22 * b00 ) * invDet;
}
return result;
}
Matrix &makeInverse( void )
{
*this = getInverse();
return *this;
}
void fromXAxisAngle( double angle )
{
_data[ 0 ] = 1;
_data[ 1 ] = 0;
_data[ 2 ] = 0;
_data[ 3 ] = 0;
_data[ 4 ] = static_cast< PRECISION >( cos( angle ) );
_data[ 5 ] = - static_cast< PRECISION >( sin( angle ) );
_data[ 6 ] = 0;
_data[ 7 ] = static_cast< PRECISION >( sin( angle ) );
_data[ 8 ] = static_cast< PRECISION >( cos( angle ) );
}
void fromYAxisAngle( double angle )
{
_data[ 0 ] = static_cast< PRECISION >( cos( angle ) );
_data[ 1 ] = 0;
_data[ 2 ] = static_cast< PRECISION >( sin( angle ) );
_data[ 3 ] = 0;
_data[ 4 ] = 1;
_data[ 5 ] = 0;
_data[ 6 ] = - static_cast< PRECISION >( sin( angle ) );
_data[ 7 ] = 0;
_data[ 8 ] = static_cast< PRECISION >( cos( angle ) );
}
void fromZAxisAngle( double angle )
{
_data[ 0 ] = static_cast< PRECISION >( cos( angle ) );
_data[ 1 ] = - static_cast< PRECISION >( sin( angle ) );
_data[ 2 ] = 0;
_data[ 3 ] = static_cast< PRECISION >( sin( angle ) );
_data[ 4 ] = static_cast< PRECISION >( cos( angle ) );
_data[ 5 ] = 0;
_data[ 6 ] = 0;
_data[ 7 ] = 0;
_data[ 8 ] = 1;
}
void fromAxisAngle( const Vector< 3, PRECISION > &axis, double angle )
{
double cosine = std::cos( angle );
double sine = std::sin( angle );
_data[ 0 ] = static_cast< PRECISION >( cosine + ( 1 - cosine ) * axis[ 0 ] * axis[ 0 ] );
_data[ 1 ] = static_cast< PRECISION >( ( 1 - cosine ) * axis[ 0 ] * axis[ 1 ] - sine * axis[ 2 ] );
_data[ 2 ] = static_cast< PRECISION >( ( 1 - cosine ) * axis[ 0 ] * axis[ 2 ] + sine * axis[ 1 ] );
_data[ 3 ] = static_cast< PRECISION >( ( 1 - cosine ) * axis[ 0 ] * axis[ 1 ] + sine * axis[ 2 ] );
_data[ 4 ] = static_cast< PRECISION >( cosine + ( 1 - cosine ) * axis[ 1 ] * axis[ 1 ] );
_data[ 5 ] = static_cast< PRECISION >( ( 1 - cosine ) * axis[ 1 ] * axis[ 2 ] - sine * axis[ 0 ] );
_data[ 6 ] = static_cast< PRECISION >( ( 1 - cosine ) * axis[ 0 ] * axis[ 2 ] - sine * axis[ 1 ] );
_data[ 7 ] = static_cast< PRECISION >( ( 1 - cosine ) * axis[ 1 ] * axis[ 2 ] + sine * axis[ 0 ] );
_data[ 8 ] = static_cast< PRECISION >( cosine + ( 1 - cosine ) * axis[ 2 ] * axis[ 2 ] );
}
Matrix ×( const Matrix &other )
{
for ( crimild::Size i = 0; i < SIZE; i++ ) {
_data[ i ] = _data[ i ] * other._data[ i ];
}
return *this;
}
template< typename U >
friend Matrix< SIZE, U > operator-( const Matrix< SIZE, U > &a );
template< typename U >
friend Matrix< SIZE, U > operator+( const Matrix< SIZE, U > &a, const Matrix< SIZE, U > &b );
template< typename U >
friend Matrix< SIZE, U > operator-( const Matrix< SIZE, U > &a, const Matrix< SIZE, U > &b );
template< typename U >
friend Matrix< SIZE, U > operator/( const Matrix< SIZE, U > &a, U scalar );
template< typename U >
friend Matrix< SIZE, U > operator*( const Matrix< SIZE, U > &a, const Matrix< SIZE, U > &b );
template< typename U >
friend Matrix< SIZE, U > operator*( const Matrix< SIZE, U > &a, U scalar );
template< typename U >
friend Matrix< SIZE, U > operator*( U scalar, const Matrix< SIZE, U > &a );
template< typename U >
friend Vector< SIZE, U > operator*( const Matrix< SIZE, U > &a, const Vector< SIZE, U > &u );
template< typename U >
friend Vector< SIZE, U > operator*( const Vector< SIZE, U > &u, const Matrix< SIZE, U > &a );
template< typename U >
friend Matrix< SIZE, U > &operator+=( Matrix< SIZE, U > &a, const Matrix< SIZE, U > &b );
template< typename U >
friend Matrix< SIZE, U > &operator-=( Matrix< SIZE, U > &a, const Matrix< SIZE, U > &b );
template< typename U >
friend Matrix< SIZE, U > &operator/=( Matrix< SIZE, U > &a, U scalar );
template< typename U >
friend Matrix< SIZE, U > &operator*=( Matrix< SIZE, U > &a, U scalar );
template< typename U >
friend Matrix< SIZE, U > &operator*=( U scalar, Matrix< SIZE, U > &a );
template< typename U >
friend Matrix< SIZE, U > &operator*=( Matrix< SIZE, U > &a, const Matrix< SIZE, U > &b );
protected:
PRECISION _data[ SIZE * SIZE ];
};
template< typename U >
Matrix< 3, U > operator-( const Matrix< 3, U > &a )
{
Matrix< 3, U > result;
result._data[ 0 ] = -a._data[ 0 ];
result._data[ 1 ] = -a._data[ 1 ];
result._data[ 2 ] = -a._data[ 2 ];
result._data[ 3 ] = -a._data[ 3 ];
result._data[ 4 ] = -a._data[ 4 ];
result._data[ 5 ] = -a._data[ 5 ];
result._data[ 6 ] = -a._data[ 6 ];
result._data[ 7 ] = -a._data[ 7 ];
result._data[ 8 ] = -a._data[ 8 ];
return result;
}
template< typename U >
Matrix< 3, U > operator+( const Matrix< 3, U > &a, const Matrix< 3, U > &b )
{
Matrix< 3, U > result;
result._data[ 0 ] = a._data[ 0 ] + b._data[ 0 ];
result._data[ 1 ] = a._data[ 1 ] + b._data[ 1 ];
result._data[ 2 ] = a._data[ 2 ] + b._data[ 2 ];
result._data[ 3 ] = a._data[ 3 ] + b._data[ 3 ];
result._data[ 4 ] = a._data[ 4 ] + b._data[ 4 ];
result._data[ 5 ] = a._data[ 5 ] + b._data[ 5 ];
result._data[ 6 ] = a._data[ 6 ] + b._data[ 6 ];
result._data[ 7 ] = a._data[ 7 ] + b._data[ 7 ];
result._data[ 8 ] = a._data[ 8 ] + b._data[ 8 ];
return result;
}
template< typename U >
Matrix< 3, U > operator-( const Matrix< 3, U > &a, const Matrix< 3, U > &b )
{
Matrix< 3, U > result;
result._data[ 0 ] = a._data[ 0 ] - b._data[ 0 ];
result._data[ 1 ] = a._data[ 1 ] - b._data[ 1 ];
result._data[ 2 ] = a._data[ 2 ] - b._data[ 2 ];
result._data[ 3 ] = a._data[ 3 ] - b._data[ 3 ];
result._data[ 4 ] = a._data[ 4 ] - b._data[ 4 ];
result._data[ 5 ] = a._data[ 5 ] - b._data[ 5 ];
result._data[ 6 ] = a._data[ 6 ] - b._data[ 6 ];
result._data[ 7 ] = a._data[ 7 ] - b._data[ 7 ];
result._data[ 8 ] = a._data[ 8 ] - b._data[ 8 ];
return result;
}
template< typename U >
Matrix< 3, U > operator/( const Matrix< 3, U > &a, U scalar )
{
assert( scalar != 0 && "Attempting to divide by zero" );
U invScalar = static_cast< U >( 1 ) / scalar;
Matrix< 3, U > result;
result._data[ 0 ] = a._data[ 0 ] * invScalar;
result._data[ 1 ] = a._data[ 1 ] * invScalar;
result._data[ 2 ] = a._data[ 2 ] * invScalar;
result._data[ 3 ] = a._data[ 3 ] * invScalar;
result._data[ 4 ] = a._data[ 4 ] * invScalar;
result._data[ 5 ] = a._data[ 5 ] * invScalar;
result._data[ 6 ] = a._data[ 6 ] * invScalar;
result._data[ 7 ] = a._data[ 7 ] * invScalar;
result._data[ 8 ] = a._data[ 8 ] * invScalar;
return result;
}
template< typename U >
Matrix< 3, U > operator*( const Matrix< 3, U > &a, const Matrix< 3, U > &b )
{
Matrix< 3, U > result;
result[ 0 ] = a._data[ 0 ] * b._data[ 0 ] + a._data[ 1 ] * b._data[ 3 ] + a._data[ 2 ] * b._data[ 6 ];
result[ 1 ] = a._data[ 0 ] * b._data[ 1 ] + a._data[ 1 ] * b._data[ 4 ] + a._data[ 2 ] * b._data[ 7 ];
result[ 2 ] = a._data[ 0 ] * b._data[ 2 ] + a._data[ 1 ] * b._data[ 5 ] + a._data[ 2 ] * b._data[ 8 ];
result[ 3 ] = a._data[ 3 ] * b._data[ 0 ] + a._data[ 4 ] * b._data[ 3 ] + a._data[ 5 ] * b._data[ 6 ];
result[ 4 ] = a._data[ 3 ] * b._data[ 1 ] + a._data[ 4 ] * b._data[ 4 ] + a._data[ 5 ] * b._data[ 7 ];
result[ 5 ] = a._data[ 3 ] * b._data[ 2 ] + a._data[ 4 ] * b._data[ 5 ] + a._data[ 5 ] * b._data[ 8 ];
result[ 6 ] = a._data[ 6 ] * b._data[ 0 ] + a._data[ 7 ] * b._data[ 3 ] + a._data[ 8 ] * b._data[ 6 ];
result[ 7 ] = a._data[ 6 ] * b._data[ 1 ] + a._data[ 7 ] * b._data[ 4 ] + a._data[ 8 ] * b._data[ 7 ];
result[ 8 ] = a._data[ 6 ] * b._data[ 2 ] + a._data[ 7 ] * b._data[ 5 ] + a._data[ 8 ] * b._data[ 8 ];
return result;
}
template< typename U >
Matrix< 3, U > operator*( const Matrix< 3, U > &a, U scalar )
{
Matrix< 3, U > result;
result._data[ 0 ] = a._data[ 0 ] * scalar;
result._data[ 1 ] = a._data[ 1 ] * scalar;
result._data[ 2 ] = a._data[ 2 ] * scalar;
result._data[ 3 ] = a._data[ 3 ] * scalar;
result._data[ 4 ] = a._data[ 4 ] * scalar;
result._data[ 5 ] = a._data[ 5 ] * scalar;
result._data[ 6 ] = a._data[ 6 ] * scalar;
result._data[ 7 ] = a._data[ 7 ] * scalar;
result._data[ 8 ] = a._data[ 8 ] * scalar;
return result;
}
template< typename U >
Matrix< 3, U > operator*( U scalar, const Matrix< 3, U > &a )
{
Matrix< 3, U > result;
result._data[ 0 ] = a._data[ 0 ] * scalar;
result._data[ 1 ] = a._data[ 1 ] * scalar;
result._data[ 2 ] = a._data[ 2 ] * scalar;
result._data[ 3 ] = a._data[ 3 ] * scalar;
result._data[ 4 ] = a._data[ 4 ] * scalar;
result._data[ 5 ] = a._data[ 5 ] * scalar;
result._data[ 6 ] = a._data[ 6 ] * scalar;
result._data[ 7 ] = a._data[ 7 ] * scalar;
result._data[ 8 ] = a._data[ 8 ] * scalar;
return result;
}
template< typename U >
Vector< 3, U > operator*( const Matrix< 3, U > &a, const Vector< 3, U > &u )
{
Vector< 3, U > result;
result[ 0 ] = a._data[ 0 ] * u[ 0 ] + a._data[ 1 ] * u[ 1 ] + a._data[ 2 ] * u[ 2 ];
result[ 1 ] = a._data[ 3 ] * u[ 0 ] + a._data[ 4 ] * u[ 1 ] + a._data[ 5 ] * u[ 2 ];
result[ 2 ] = a._data[ 6 ] * u[ 0 ] + a._data[ 7 ] * u[ 1 ] + a._data[ 8 ] * u[ 2 ];
return result;
}
template< typename U >
Vector< 3, U > operator*( const Vector< 3, U > &u, const Matrix< 3, U > &a )
{
Vector< 3, U > result;
result[ 0 ] = a._data[ 0 ] * u[ 0 ] + a._data[ 1 ] * u[ 1 ] + a._data[ 2 ] * u[ 2 ];
result[ 1 ] = a._data[ 3 ] * u[ 0 ] + a._data[ 4 ] * u[ 1 ] + a._data[ 5 ] * u[ 2 ];
result[ 2 ] = a._data[ 6 ] * u[ 0 ] + a._data[ 7 ] * u[ 1 ] + a._data[ 8 ] * u[ 2 ];
return result;
}
template< typename U >
Matrix< 3, U > &operator+=( Matrix< 3, U > &a, const Matrix< 3, U > &b )
{
a._data[ 0 ] += b._data[ 0 ];
a._data[ 1 ] += b._data[ 1 ];
a._data[ 2 ] += b._data[ 2 ];
a._data[ 3 ] += b._data[ 3 ];
a._data[ 4 ] += b._data[ 4 ];
a._data[ 5 ] += b._data[ 5 ];
a._data[ 6 ] += b._data[ 6 ];
a._data[ 7 ] += b._data[ 7 ];
a._data[ 8 ] += b._data[ 8 ];
return a;
}
template< typename U >
Matrix< 3, U > &operator-=( Matrix< 3, U > &a, const Matrix< 3, U > &b )
{
a._data[ 0 ] -= b._data[ 0 ];
a._data[ 1 ] -= b._data[ 1 ];
a._data[ 2 ] -= b._data[ 2 ];
a._data[ 3 ] -= b._data[ 3 ];
a._data[ 4 ] -= b._data[ 4 ];
a._data[ 5 ] -= b._data[ 5 ];
a._data[ 6 ] -= b._data[ 6 ];
a._data[ 7 ] -= b._data[ 7 ];
a._data[ 8 ] -= b._data[ 8 ];
return a;
}
template< typename U >
Matrix< 3, U > &operator/=( Matrix< 3, U > &a, U scalar )
{
assert( scalar != 0 && "Attempting to divide by zero" );
U invScalar = static_cast< U >( 1 ) / scalar;
a._data[ 0 ] *= invScalar;
a._data[ 1 ] *= invScalar;
a._data[ 2 ] *= invScalar;
a._data[ 3 ] *= invScalar;
a._data[ 4 ] *= invScalar;
a._data[ 5 ] *= invScalar;
a._data[ 6 ] *= invScalar;
a._data[ 7 ] *= invScalar;
a._data[ 8 ] *= invScalar;
return a;
}
template< typename U >
Matrix< 3, U > &operator*=( Matrix< 3, U > &a, U scalar )
{
a._data[ 0 ] *= scalar;
a._data[ 1 ] *= scalar;
a._data[ 2 ] *= scalar;
a._data[ 3 ] *= scalar;
a._data[ 4 ] *= scalar;
a._data[ 5 ] *= scalar;
a._data[ 6 ] *= scalar;
a._data[ 7 ] *= scalar;
a._data[ 8 ] *= scalar;
return a;
}
template< typename U >
Matrix< 3, U > &operator*=( Matrix< 3, U > &a, const Matrix< 3, U > &b )
{
a = a * b;
return a;
}
template< typename U >
Matrix< 4, U > operator*( const Matrix< 4, U > &a, const Matrix< 4, U > &b )
{
Matrix< 4, U > result;
memset( &result[ 0 ], 0, sizeof( U ) * 16 );
for ( crimild::Size i = 0; i < 4; i++ ) {
for ( crimild::Size j = 0; j < 4; j++ ) {
for ( crimild::Size k = 0; k < 4; k++ ) {
result[ i * 4 + j ] += a[ i * 4 + k ] * b[ k * 4 + j ];
}
}
}
return result;
}
template< typename U >
Vector< 4, U > operator*( const Matrix< 4, U > &m, const Vector< 4, U > &v )
{
Vector< 4, U > result;
result[ 0 ] = m[ 0 ] * v[ 0 ] +
m[ 1 ] * v[ 1 ] +
m[ 2 ] * v[ 2 ] +
m[ 3 ] * v[ 3 ];
result[ 1 ] = m[ 4 ] * v[ 0 ] +
m[ 5 ] * v[ 1 ] +
m[ 6 ] * v[ 2 ] +
m[ 7 ] * v[ 3 ];
result[ 2 ] = m[ 8 ] * v[ 0 ] +
m[ 9 ] * v[ 1 ] +
m[ 10 ] * v[ 2 ] +
m[ 11 ] * v[ 3 ];
result[ 3 ] = m[ 12 ] * v[ 0 ] +
m[ 13 ] * v[ 1 ] +
m[ 14 ] * v[ 2 ] +
m[ 15 ] * v[ 3 ];
return result;
}
template< typename U >
Vector< 4, U > operator*( const Vector< 4, U > &v, const Matrix< 4, U > &m )
{
Vector< 4, U > result;
result[ 0 ] = m[ 0 ] * v[ 0 ] +
m[ 1 ] * v[ 1 ] +
m[ 2 ] * v[ 2 ] +
m[ 3 ] * v[ 3 ];
result[ 1 ] = m[ 4 ] * v[ 0 ] +
m[ 5 ] * v[ 1 ] +
m[ 6 ] * v[ 2 ] +
m[ 7 ] * v[ 3 ];
result[ 2 ] = m[ 8 ] * v[ 0 ] +
m[ 9 ] * v[ 1 ] +
m[ 10 ] * v[ 2 ] +
m[ 11 ] * v[ 3 ];
result[ 3 ] = m[ 12 ] * v[ 0 ] +
m[ 13 ] * v[ 1 ] +
m[ 14 ] * v[ 2 ] +
m[ 15 ] * v[ 3 ];
return result;
}
template< crimild::Size SIZE, typename PRECISION >
std::ostream &operator<<( std::ostream &out, const Matrix< SIZE, PRECISION > &m )
{
out << std::setiosflags( std::ios::fixed | std::ios::showpoint )
<< std::setprecision( 10 );
out << "(";
for ( crimild::Size i = 0; i < SIZE; i++ ) {
for ( crimild::Size j = 0; j < SIZE; j++ ) {
out << m[ i * SIZE + j ];
if ( j < SIZE - 1 || i < SIZE - 1 ) {
out << ", ";
}
}
if ( i < SIZE - 1 ) {
out << "\n";
}
}
out << ")";
return out;
}
typedef Matrix< 3, int > Matrix3i;
typedef Matrix< 3, float > Matrix3f;
typedef Matrix< 3, double > Matrix3d;
typedef Matrix< 4, int > Matrix4i;
typedef Matrix< 4, float > Matrix4f;
typedef Matrix< 4, double > Matrix4d;
}
#endif
| [
"hhsaez@gmail.com"
] | hhsaez@gmail.com |
fc94c6c0a52e738b2e5867a0433be601e4171614 | 5486c8a5695a885152a6ff0278f64bc32bbf64b9 | /UVa/10079 - Pizza Cutting.cpp | d3b3d09770e873c36572e1acd9a703aa49040774 | [] | no_license | emrul-chy/Competitive-Programming | 3a3c5fd8fb41320d924c309873868a6d81585bf4 | b22fddadaec2c40c1ffebaf594ded94434443662 | refs/heads/master | 2021-01-10T23:37:36.250883 | 2018-01-18T16:39:09 | 2018-01-18T16:39:09 | 70,418,520 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 192 | cpp | #include <stdio.h>
int main()
{
long long int n;
while(scanf("%lld", &n)==1)
{
if(n<0) break;
printf("%lld\n", ((n*(n+1))/2) + 1);
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
c9bbf8bce406d0fdad60eaea5d7c348593640319 | d20cd8d62e96ef9200126a8933d6cfc0363c8f7c | /src/partitioning/local_partition.cc | bb2052366fde4eca16fed28845e2b65d474699f5 | [
"Apache-2.0"
] | permissive | Pandinosaurus/legate.pandas | 565f9783ce8b87b5bc557b4de480af278b7e6eb4 | 9875e6f22c67c89f6fceed09e5d55d0126db2b70 | refs/heads/master | 2023-07-19T06:08:23.953705 | 2021-07-09T00:30:35 | 2021-07-09T00:30:35 | 358,820,890 | 0 | 0 | Apache-2.0 | 2021-08-08T06:14:49 | 2021-04-17T08:05:54 | C++ | UTF-8 | C++ | false | false | 3,905 | cc | /* Copyright 2021 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include "partitioning/local_partition.h"
#include "partitioning/local_partition_args.h"
#include "column/detail/column.h"
#include "copy/gather.h"
#include "table/row_wrappers.h"
#include "util/allocator.h"
#include "util/zip_for_each.h"
namespace legate {
namespace pandas {
using namespace Legion;
using ColumnView = detail::Column;
namespace partition {
namespace detail {
void hash_all(LocalPartitionArgs &args, std::vector<uint32_t> &radix, std::vector<uint32_t> &hist)
{
const size_t num_pieces = args.num_pieces;
const size_t size = args.input[0].num_elements();
table::RowHasher hf{};
std::vector<ColumnView> in_keys;
for (auto idx : args.key_indices) in_keys.push_back(args.input[idx].view());
for (size_t i = 0; i < size; ++i) {
table::Row key{in_keys, i};
auto r = static_cast<uint32_t>(hf(key) % num_pieces);
++hist[r];
radix[i] = r;
}
}
static void histogram_to_ranges(LocalPartitionArgs &args,
std::vector<int64_t> &offsets,
const std::vector<uint32_t> &hist)
{
// Exclusive sum
for (size_t i = 1; i < offsets.size(); ++i) offsets[i] = offsets[i - 1] + hist[i - 1];
const coord_t lo = args.input[0].shape().lo[0];
const coord_t y = args.hist_rect.lo[1];
for (coord_t i = 0; i < args.num_pieces; ++i)
args.hist_acc[Point<2>(i, y)] = Rect<1>(lo + offsets[i], lo + offsets[i + 1] - 1);
}
static void radix_to_mapping(std::vector<int64_t> &mapping,
std::vector<int64_t> &offsets,
const std::vector<uint32_t> &radix,
const std::vector<uint32_t> &hist,
const uint32_t num_pieces)
{
const size_t size = radix.size();
for (size_t i = 0; i < size; ++i) mapping[offsets[radix[i]]++] = i;
}
} // namespace detail
/*static*/ int64_t LocalPartitionTask::cpu_variant(const Task *task,
const std::vector<PhysicalRegion> ®ions,
Context context,
Runtime *runtime)
{
Deserializer ctx{task, regions};
detail::LocalPartitionArgs args;
deserialize(ctx, args);
int64_t size = static_cast<int64_t>(args.input[0].num_elements());
std::vector<uint32_t> radix(size);
std::vector<uint32_t> hist(args.num_pieces, 0);
detail::hash_all(args, radix, hist);
std::vector<int64_t> offsets(args.num_pieces + 1, 0);
detail::histogram_to_ranges(args, offsets, hist);
std::vector<int64_t> mapping(size);
// Note: detail::radix_to_mapping consumes offsets computed by detail::histogram_to_ranges
detail::radix_to_mapping(mapping, offsets, radix, hist, args.num_pieces);
alloc::DeferredBufferAllocator allocator;
util::for_each(args.output, args.input, [&](auto &output, auto &input) {
auto &&gathered =
copy::gather(input.view(), mapping, false, copy::OutOfRangePolicy::IGNORE, allocator);
output.return_from_view(allocator, gathered);
});
return size;
}
static void __attribute__((constructor)) register_tasks(void)
{
LocalPartitionTask::register_variants_with_return<int64_t, int64_t>();
}
} // namespace partition
} // namespace pandas
} // namespace legate
| [
"wonchanl@nvidia.com"
] | wonchanl@nvidia.com |
38eeb555cc6954419184172182788070ee662bd6 | f73fe176c2759183a89a71124a194da839665b67 | /alledge/Cameranode.h | 5ebce6663c8e5eb0ea25a00e9e4602459d313657 | [] | no_license | trezker/alledge | 8ea124e23922cd934c5d95dc751566d2239aa3cd | a9449706dca1fa9455c764c2b1b92ff7b4ec1ade | refs/heads/master | 2022-01-15T11:08:30.957983 | 2022-01-05T21:00:48 | 2022-01-05T21:00:48 | 431,059 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 725 | h | #ifndef Cameranode_h
#define Cameranode_h
#include <vector>
#include "Vector3.h"
#include "Scenenode.h"
#include "Quat.h"
class Cameranode: public Scenenode
{
public:
Cameranode();
void Look_at(Vector3 p);
Vector3 Get_up();
Vector3 Get_front();
Vector3 Get_right();
void Set_position(Vector3 v);
void Set_rotation(Vector3 v);
Vector3 Get_position();
Vector3 Get_rotation();
void Rotate_local_axis(Vector3 v);
void Set_rotate_around_world_origo(bool t);
virtual void Prerender();
virtual void Postrender();
private:
Vector3 position;
Vector3 rotation;
bool lookat;
Vector3 lookat_target;
Vector3 up;
Vector3 front;
Vector3 right;
quat4_t quat_total;
bool rotate_around_world_origo;
};
#endif
| [
"trezker@gmail.com"
] | trezker@gmail.com |
27e3c3731b38935989cef62a7609e127182b2995 | d5bd083dbcacce8cf62ebbd73c77c14c8247e057 | /external/skia/tests/PathOpsSimplifyQuadThreadedTest.cpp | 047aa6b7951d7c6bb4e1319603289bd1fe1ecff8 | [
"BSD-3-Clause",
"SGI-B-2.0"
] | permissive | RetronixTechInc/android-retronix | ab0e10840dab5dc7b0879737953ebf2e1916f2b0 | cd7d794dea51c3b287da0d35ddb18c1bdef00372 | refs/heads/RTX_NXP_Android601 | 2021-11-16T03:58:58.169998 | 2021-11-15T01:51:02 | 2021-11-15T01:51:02 | 198,991,737 | 4 | 5 | null | 2020-03-08T23:21:29 | 2019-07-26T09:49:01 | Java | UTF-8 | C++ | false | false | 4,271 | cpp | /*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "PathOpsExtendedTest.h"
#include "PathOpsThreadedCommon.h"
static void testSimplifyQuadsMain(PathOpsThreadState* data)
{
SkASSERT(data);
PathOpsThreadState& state = *data;
char pathStr[1024];
bool progress = state.fReporter->verbose(); // FIXME: break out into its own parameter?
if (progress) {
sk_bzero(pathStr, sizeof(pathStr));
}
int ax = state.fA & 0x03;
int ay = state.fA >> 2;
int bx = state.fB & 0x03;
int by = state.fB >> 2;
int cx = state.fC & 0x03;
int cy = state.fC >> 2;
int dx = state.fD & 0x03;
int dy = state.fD >> 2;
for (int e = 0 ; e < 16; ++e) {
int ex = e & 0x03;
int ey = e >> 2;
for (int f = e ; f < 16; ++f) {
int fx = f & 0x03;
int fy = f >> 2;
for (int g = f ; g < 16; ++g) {
int gx = g & 0x03;
int gy = g >> 2;
for (int h = g ; h < 16; ++h) {
int hx = h & 0x03;
int hy = h >> 2;
SkPath path, out;
path.setFillType(SkPath::kWinding_FillType);
path.moveTo(SkIntToScalar(ax), SkIntToScalar(ay));
path.quadTo(SkIntToScalar(bx), SkIntToScalar(by),
SkIntToScalar(cx), SkIntToScalar(cy));
path.lineTo(SkIntToScalar(dx), SkIntToScalar(dy));
path.close();
path.moveTo(SkIntToScalar(ex), SkIntToScalar(ey));
path.lineTo(SkIntToScalar(fx), SkIntToScalar(fy));
path.quadTo(SkIntToScalar(gx), SkIntToScalar(gy),
SkIntToScalar(hx), SkIntToScalar(hy));
path.close();
if (progress) {
static int quadTest = 65;
char* str = pathStr;
str += sprintf(str, "static void testQuads%d(skiatest::Reporter* reporter,"
"const char* filename) {\n", quadTest);
str += sprintf(str, " SkPath path;\n");
str += sprintf(str, " path.moveTo(%d, %d);\n", ax, ay);
str += sprintf(str, " path.quadTo(%d, %d, %d, %d);\n", bx, by, cx, cy);
str += sprintf(str, " path.lineTo(%d, %d);\n", dx, dy);
str += sprintf(str, " path.close();\n");
str += sprintf(str, " path.moveTo(%d, %d);\n", ex, ey);
str += sprintf(str, " path.lineTo(%d, %d);\n", fx, fy);
str += sprintf(str, " path.quadTo(%d, %d, %d, %d);\n", gx, gy, hx, hy);
str += sprintf(str, " path.close();\n");
str += sprintf(str, " testSimplify(reporter, path, filename);\n");
str += sprintf(str, "}\n");
outputProgress(state.fPathStr, pathStr, SkPath::kWinding_FillType);
}
testSimplify(path, false, out, state, pathStr);
path.setFillType(SkPath::kEvenOdd_FillType);
if (progress) {
outputProgress(state.fPathStr, pathStr, SkPath::kEvenOdd_FillType);
}
testSimplify(path, true, out, state, pathStr);
}
}
}
}
}
DEF_TEST(PathOpsSimplifyQuadsThreaded, reporter) {
initializeTests(reporter, "testQuads");
PathOpsThreadedTestRunner testRunner(reporter);
int a = 0;
for (; a < 16; ++a) {
for (int b = a ; b < 16; ++b) {
for (int c = b ; c < 16; ++c) {
for (int d = c; d < 16; ++d) {
*testRunner.fRunnables.append() = SkNEW_ARGS(PathOpsThreadedRunnable,
(&testSimplifyQuadsMain, a, b, c, d, &testRunner));
}
if (!reporter->allowExtendedTest()) goto finish;
}
}
}
finish:
testRunner.render();
ShowTestArray("testQuads");
}
| [
"townwang@retronix.com.tw"
] | townwang@retronix.com.tw |
056e7bdffa218f8f733ba33691395127df62817f | 528c1fba524ca0338de39e206b2ae4bf064200a7 | /LP1/Derzu/Roteiro_2/Exercício_2/Pessoa.hpp | f45502920830aac05ec7ceb30338216df5a4150b | [] | no_license | koliveiraba/LP1 | 6a336eceb45893a2031f93058c466a8c85c2b140 | 8f8972e10836c348cc8baa23dbe30b64b6aefb73 | refs/heads/master | 2023-04-07T21:45:02.168935 | 2020-03-17T20:34:11 | 2020-03-17T20:34:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 640 | hpp | #ifndef PESSOA_HPP
#define PESSOA_HPP
#include "Endereco.hpp"
class Pessoa
{
private:
std::string nome;
Endereco endereco;
std::string telefone;
public:
Pessoa(std::string name);
Pessoa(std::string name, Endereco adress, std::string phone);
std::string getNome();
Endereco getEndereco();
std::string getEnderecoCompleto();
std::string getTelefone();
void setNome(std::string);
void setEndereco(std::string, std::string, std::string, std::string, std::string, std::string);
void setTelefone(std::string);
};
#endif | [
"noreply@github.com"
] | noreply@github.com |
a55652ce07f099179f4ecfd3ccfd8cb140f3b365 | 07d738dca3f651041a0416f9ab554eb90b9c94a9 | /src/allegro/keyboard.hpp | 637d3c476d4122b66dd266f978190eecd1787c26 | [] | no_license | gahag-aeds/aeds1-tp1 | 43393b0afe4b44140c4227c82f02ef83f8619f37 | d0b3d6f6c9f8946801e8863aa6a1495414a264e4 | refs/heads/master | 2021-12-04T03:32:26.978718 | 2021-11-20T21:11:12 | 2021-11-20T21:11:12 | 93,907,209 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 599 | hpp | #ifndef __ALLEGRO_KEYBOARD_HPP__
#define __ALLEGRO_KEYBOARD_HPP__
#include <functional>
#include <map>
#include <allegro5/allegro.h>
typedef int ALLEGRO_KEY;
namespace Allegro {
class Keyboard {
public:
static void Install();
static ALLEGRO_EVENT_SOURCE* EventSource();
static void UpdateKeysState(
const ALLEGRO_EVENT&,
std::map<int, bool>& keys // map<keycode, pressed>
);
static void HandleKeyPress(
const ALLEGRO_EVENT&,
const std::map<int, std::function<void()>>& // map<keycode, action>
);
};
}
#endif /* __ALLEGRO_KEYBOARD_HPP__ */
| [
"gahag@hotmail.com.br"
] | gahag@hotmail.com.br |
01b40cd6a96100ae9d7300b8f91796d9826369fa | 8d52c40a3c5acc0a374198566d6b98d071aa1f86 | /cppcheck/data/c_files/498.cpp | 87f19529f9f4e3e09c25853f0d56041cd7239643 | [
"MIT"
] | permissive | awsm-research/LineVul | 8f6e6a7ee34c50b2b8d7d4a2d79b680f38c141d6 | e739809970189f715aef6a707c1543786e3a9ec8 | refs/heads/main | 2023-04-29T04:03:06.454615 | 2023-04-15T06:59:41 | 2023-04-15T06:59:41 | 449,643,469 | 51 | 23 | null | null | null | null | UTF-8 | C++ | false | false | 6,811 | cpp | tiffcp(TIFF* in, TIFF* out)
{
uint16 bitspersample, samplesperpixel = 1;
uint16 input_compression, input_photometric = PHOTOMETRIC_MINISBLACK;
copyFunc cf;
uint32 width, length;
struct cpTag* p;
CopyField(TIFFTAG_IMAGEWIDTH, width);
CopyField(TIFFTAG_IMAGELENGTH, length);
CopyField(TIFFTAG_BITSPERSAMPLE, bitspersample);
CopyField(TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
if (compression != (uint16)-1)
TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
else
CopyField(TIFFTAG_COMPRESSION, compression);
TIFFGetFieldDefaulted(in, TIFFTAG_COMPRESSION, &input_compression);
TIFFGetFieldDefaulted(in, TIFFTAG_PHOTOMETRIC, &input_photometric);
if (input_compression == COMPRESSION_JPEG) {
/* Force conversion to RGB */
TIFFSetField(in, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
} else if (input_photometric == PHOTOMETRIC_YCBCR) {
/* Otherwise, can't handle subsampled input */
uint16 subsamplinghor,subsamplingver;
TIFFGetFieldDefaulted(in, TIFFTAG_YCBCRSUBSAMPLING,
&subsamplinghor, &subsamplingver);
if (subsamplinghor!=1 || subsamplingver!=1) {
fprintf(stderr, "tiffcp: %s: Can't copy/convert subsampled image.\n",
TIFFFileName(in));
return FALSE;
}
}
if (compression == COMPRESSION_JPEG) {
if (input_photometric == PHOTOMETRIC_RGB &&
jpegcolormode == JPEGCOLORMODE_RGB)
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
else
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, input_photometric);
}
else if (compression == COMPRESSION_SGILOG
|| compression == COMPRESSION_SGILOG24)
TIFFSetField(out, TIFFTAG_PHOTOMETRIC,
samplesperpixel == 1 ?
PHOTOMETRIC_LOGL : PHOTOMETRIC_LOGLUV);
else if (input_compression == COMPRESSION_JPEG &&
samplesperpixel == 3 ) {
/* RGB conversion was forced above
hence the output will be of the same type */
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
}
else
CopyTag(TIFFTAG_PHOTOMETRIC, 1, TIFF_SHORT);
if (fillorder != 0)
TIFFSetField(out, TIFFTAG_FILLORDER, fillorder);
else
CopyTag(TIFFTAG_FILLORDER, 1, TIFF_SHORT);
/*
* Will copy `Orientation' tag from input image
*/
TIFFGetFieldDefaulted(in, TIFFTAG_ORIENTATION, &orientation);
switch (orientation) {
case ORIENTATION_BOTRIGHT:
case ORIENTATION_RIGHTBOT: /* XXX */
TIFFWarning(TIFFFileName(in), "using bottom-left orientation");
orientation = ORIENTATION_BOTLEFT;
/* fall thru... */
case ORIENTATION_LEFTBOT: /* XXX */
case ORIENTATION_BOTLEFT:
break;
case ORIENTATION_TOPRIGHT:
case ORIENTATION_RIGHTTOP: /* XXX */
default:
TIFFWarning(TIFFFileName(in), "using top-left orientation");
orientation = ORIENTATION_TOPLEFT;
/* fall thru... */
case ORIENTATION_LEFTTOP: /* XXX */
case ORIENTATION_TOPLEFT:
break;
}
TIFFSetField(out, TIFFTAG_ORIENTATION, orientation);
/*
* Choose tiles/strip for the output image according to
* the command line arguments (-tiles, -strips) and the
* structure of the input image.
*/
if (outtiled == -1)
outtiled = TIFFIsTiled(in);
if (outtiled) {
/*
* Setup output file's tile width&height. If either
* is not specified, use either the value from the
* input image or, if nothing is defined, use the
* library default.
*/
if (tilewidth == (uint32) -1)
TIFFGetField(in, TIFFTAG_TILEWIDTH, &tilewidth);
if (tilelength == (uint32) -1)
TIFFGetField(in, TIFFTAG_TILELENGTH, &tilelength);
TIFFDefaultTileSize(out, &tilewidth, &tilelength);
TIFFSetField(out, TIFFTAG_TILEWIDTH, tilewidth);
TIFFSetField(out, TIFFTAG_TILELENGTH, tilelength);
} else {
/*
* RowsPerStrip is left unspecified: use either the
* value from the input image or, if nothing is defined,
* use the library default.
*/
if (rowsperstrip == (uint32) 0) {
if (!TIFFGetField(in, TIFFTAG_ROWSPERSTRIP,
&rowsperstrip)) {
rowsperstrip =
TIFFDefaultStripSize(out, rowsperstrip);
}
if (rowsperstrip > length && rowsperstrip != (uint32)-1)
rowsperstrip = length;
}
else if (rowsperstrip == (uint32) -1)
rowsperstrip = length;
TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
}
if (config != (uint16) -1)
TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
else
CopyField(TIFFTAG_PLANARCONFIG, config);
if (samplesperpixel <= 4)
CopyTag(TIFFTAG_TRANSFERFUNCTION, 4, TIFF_SHORT);
CopyTag(TIFFTAG_COLORMAP, 4, TIFF_SHORT);
/* SMinSampleValue & SMaxSampleValue */
switch (compression) {
case COMPRESSION_JPEG:
TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
break;
case COMPRESSION_JBIG:
CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);
CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);
CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);
CopyTag(TIFFTAG_FAXDCS, 1, TIFF_ASCII);
break;
case COMPRESSION_LZW:
case COMPRESSION_ADOBE_DEFLATE:
case COMPRESSION_DEFLATE:
case COMPRESSION_LZMA:
if (predictor != (uint16)-1)
TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
else
CopyField(TIFFTAG_PREDICTOR, predictor);
if (preset != -1) {
if (compression == COMPRESSION_ADOBE_DEFLATE
|| compression == COMPRESSION_DEFLATE)
TIFFSetField(out, TIFFTAG_ZIPQUALITY, preset);
else if (compression == COMPRESSION_LZMA)
TIFFSetField(out, TIFFTAG_LZMAPRESET, preset);
}
break;
case COMPRESSION_CCITTFAX3:
case COMPRESSION_CCITTFAX4:
if (compression == COMPRESSION_CCITTFAX3) {
if (g3opts != (uint32) -1)
TIFFSetField(out, TIFFTAG_GROUP3OPTIONS,
g3opts);
else
CopyField(TIFFTAG_GROUP3OPTIONS, g3opts);
} else
CopyTag(TIFFTAG_GROUP4OPTIONS, 1, TIFF_LONG);
CopyTag(TIFFTAG_BADFAXLINES, 1, TIFF_LONG);
CopyTag(TIFFTAG_CLEANFAXDATA, 1, TIFF_LONG);
CopyTag(TIFFTAG_CONSECUTIVEBADFAXLINES, 1, TIFF_LONG);
CopyTag(TIFFTAG_FAXRECVPARAMS, 1, TIFF_LONG);
CopyTag(TIFFTAG_FAXRECVTIME, 1, TIFF_LONG);
CopyTag(TIFFTAG_FAXSUBADDRESS, 1, TIFF_ASCII);
break;
}
{
uint32 len32;
void** data;
if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &len32, &data))
TIFFSetField(out, TIFFTAG_ICCPROFILE, len32, data);
}
{
uint16 ninks;
const char* inknames;
if (TIFFGetField(in, TIFFTAG_NUMBEROFINKS, &ninks)) {
TIFFSetField(out, TIFFTAG_NUMBEROFINKS, ninks);
if (TIFFGetField(in, TIFFTAG_INKNAMES, &inknames)) {
int inknameslen = strlen(inknames) + 1;
const char* cp = inknames;
while (ninks > 1) {
cp = strchr(cp, '\0');
cp++;
inknameslen += (strlen(cp) + 1);
ninks--;
}
TIFFSetField(out, TIFFTAG_INKNAMES, inknameslen, inknames);
}
}
}
{
unsigned short pg0, pg1;
if (pageInSeq == 1) {
if (pageNum < 0) /* only one input file */ {
if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1))
TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1);
} else
TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0);
} else {
if (TIFFGetField(in, TIFFTAG_PAGENUMBER, &pg0, &pg1)) {
if (pageNum < 0) /* only one input file */
TIFFSetField(out, TIFFTAG_PAGENUMBER, pg0, pg1);
else
TIFFSetField(out, TIFFTAG_PAGENUMBER, pageNum++, 0);
}
}
}
for (p = tags; p < &tags[NTAGS]; p++)
CopyTag(p->tag, p->count, p->type);
cf = pickCopyFunc(in, out, bitspersample, samplesperpixel);
return (cf ? (*cf)(in, out, length, width, samplesperpixel) : FALSE);
}
| [
"michaelfu1998@gmail.com"
] | michaelfu1998@gmail.com |
7df8755d970acd09ea8218396040f7cf4d5b5bf9 | 32625241eadbe4c2b4267e60e170d38b84a245a1 | /source code/raspberrypi-code/examples/LoRaWAN_new/LoRaWAN_P2P_02_send_packets.cpp | da9b5a09043d6af47315da5ad822129c15101541 | [] | no_license | junyang28/paper-lorabee | 2bcb48b17e8b29b0e4f7a5cd20dd29757e665bcb | e8981567ebff54d35032533f8350f79edf54f77a | refs/heads/master | 2022-11-29T14:54:56.608280 | 2020-08-10T14:15:47 | 2020-08-10T14:15:47 | 282,961,701 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,209 | cpp | /*
* ------ P2P Code Example --------
*
* Explanation: This example shows how to configure the module
* for P2P mode and the corresponding parameters. After this,
* the example shows how to send packets to other radio modules
* which must be set with the same radio settings
*
* Copyright (C) 2015 Libelium Comunicaciones Distribuidas S.L.
* http://www.libelium.com
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Version: 0.4
* Design: David Gascon
* Implementation: Luismi Marti, Ruben Martin
*/
#include "arduPiLoRaWAN.h"
// socket to use
//////////////////////////////////////////////
uint8_t sock = SOCKET0;
//////////////////////////////////////////////
// define radio settings
//////////////////////////////////////////////
uint8_t power = 15;
//uint32_t frequency = 915600000;
uint32_t frequency = 915529000;
//uint32_t frequency = 916000000;
char spreading_factor[] = "sf11";
char coding_rate[] = "4/5";
uint16_t bandwidth = 500;
//uint16_t bandwidth = 62.5;
//char crc_mode[] = "on";
char crc_mode[] = "off";
//////////////////////////////////////////////
// define functions
uint8_t radioModuleSetup(void);
// define data to send
//char data[] = "0102030405060708090A0B0C0D0E0F";
//char data[] = "111111111111111";
//char data[] = "000000000000000";
char data[] = "0000";
// variable
uint8_t error;
void setup()
{
printf("Radio P2P example - Sending packets\n\n");
// module setup
error = radioModuleSetup();
// Check status
if (error == 0)
{
printf("Module configured OK\n");
}
else
{
printf("Module configured ERROR\n");
}
}
char data0[] = "0000";
char data1[] = "1000";
char data2[] = "0100";
char data3[] = "0010";
char data00[] = "0001";
char data01[] = "F000";
char data02[] = "0F00";
char data03[] = "00F0";
char data000[] = "000F";
char data001[] = "4000";
char data002[] = "0400";
char data003[] = "0040";
char data0000[] = "0004";
char data0001[] = "0D";
char data0002[] = "0E";
char data0003[] = "0F";
char data00000[] = "00000";
char data00001[] = "00001";
char data00002[] = "00002";
char data00003[] = "00003";
char data000000[] = "000000";
char data000001[] = "000001";
char data000002[] = "000002";
char data000003[] = "000003";
void loop()
{
// Send packet
error = LoRaWAN.sendRadio(data0);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data1);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data2);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data3);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data00);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data01);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data02);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data03);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data000);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data001);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data002);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data003);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data0000);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
/*
error = LoRaWAN.sendRadio(data0001);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data0002);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data0003);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data00000);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data00001);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data00002);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data00003);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data000000);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data000001);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data000002);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
error = LoRaWAN.sendRadio(data000003);
if (error == 0)
{
printf("--> Packet sent OK\n");
}
else
{
printf("Error waiting for packets. error = %d\n", error);
}
*/
/*
if(bandwidth == 125){
bandwidth = 250;
} else{
bandwidth = 125;
}
LoRaWAN.setRadioBW(bandwidth);
*/
// Check status
delay(1000);
}
/***********************************************************************************
*
* radioModuleSetup()
*
* This function includes all functions related to the module setup and configuration
* The user must keep in mind that each time the module powers on, all settings are set
* to default values. So it is better to develop a specific function including all steps
* for setup and call it everytime the module powers on.
*
*
***********************************************************************************/
uint8_t radioModuleSetup()
{
uint8_t status = 0;
uint8_t e = 0;
//////////////////////////////////////////////
// 1. switch on
//////////////////////////////////////////////
e = LoRaWAN.ON(sock);
// Check status
if (e == 0)
{
printf("1. Switch ON OK\n");
}
else
{
printf("1. Switch ON error = %d\n",e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 2. Enable P2P mode
//////////////////////////////////////////////
e = LoRaWAN.macPause();
// Check status
if (e == 0)
{
printf("2. P2P mode enabled OK\n");
}
else
{
printf("2. Enable P2P mode error = %d\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 3. Set/Get Radio Power
//////////////////////////////////////////////
// Set power
e = LoRaWAN.setRadioPower(power);
// Check status
if (e == 0)
{
printf("3.1. Set Radio Power OK\n");
}
else
{
printf("3.1. Set Radio Power error = %d\n", e);
status = 1;
}
// Get power
e = LoRaWAN.getRadioPower();
// Check status
if (e == 0)
{
printf("3.2. Get Radio Power OK. ");
printf("Power: %d\n",LoRaWAN._radioPower);
}
else
{
printf("3.2. Get Radio Power error = %d\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 4. Set/Get Radio Frequency
//////////////////////////////////////////////
// Set frequency
e = LoRaWAN.setRadioFreq(frequency);
// Check status
if (e == 0)
{
printf("4.1. Set Radio Frequency OK\n");
}
else
{
printf("4.1. Set Radio Frequency error = %d\n", error);
status = 1;
}
// Get frequency
e = LoRaWAN.getRadioFreq();
// Check status
if (e == 0)
{
printf("4.2. Get Radio Frequency OK. ");
printf("Frequency: %d\n", LoRaWAN._radioFreq);
}
else
{
printf("4.2. Get Radio Frequency error = %d\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 5. Set/Get Radio Spreading Factor (SF)
//////////////////////////////////////////////
// Set SF
e = LoRaWAN.setRadioSF(spreading_factor);
// Check status
if (e == 0)
{
printf("5.1. Set Radio SF OK\n");
}
else
{
printf("5.1. Set Radio SF error = %e\n", e);
status = 1;
}
// Get SF
e = LoRaWAN.getRadioSF();
// Check status
if (e == 0)
{
printf("5.2. Get Radio SF OK. ");
printf("Spreading Factor: %s\n", LoRaWAN._radioSF);
}
else
{
printf("5.2. Get Radio SF error = %d\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 6. Set/Get Radio Coding Rate (CR)
//////////////////////////////////////////////
// Set CR
e = LoRaWAN.setRadioCR(coding_rate);
// Check status
if (e == 0)
{
printf("6.1. Set Radio CR OK\n");
}
else
{
printf("6.1. Set Radio CR error = %d\n", e);
status = 1;
}
// Get CR
e = LoRaWAN.getRadioCR();
// Check status
if (e == 0)
{
printf("6.2. Get Radio CR OK. ");
printf("Coding Rate: %s\n",LoRaWAN._radioCR);
}
else
{
printf("6.2. Get Radio CR error = %d\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 7. Set/Get Radio Bandwidth (BW)
//////////////////////////////////////////////
// Set BW
e = LoRaWAN.setRadioBW(bandwidth);
// Check status
if (e == 0)
{
printf("7.1. Set Radio BW OK\n");
}
else
{
printf("7.1. Set Radio BW error = %d\n", e);
}
// Get BW
e = LoRaWAN.getRadioBW();
// Check status
if (e == 0)
{
printf("7.2. Get Radio BW OK. ");
printf("Bandwidth: %u\n", LoRaWAN._radioBW);
}
else
{
printf("7.2. Get Radio BW error = %d\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
//////////////////////////////////////////////
// 8. Set/Get Radio CRC mode
//////////////////////////////////////////////
// Set CRC
e = LoRaWAN.setRadioCRC(crc_mode);
// Check status
if (e == 0)
{
printf("8.1. Set Radio CRC mode OK\n");
}
else
{
printf("8.1. Set Radio CRC mode error = %d\n", e);
status = 1;
}
// Get CRC
e = LoRaWAN.getRadioCRC();
// Check status
if (e == 0)
{
printf("8.2. Get Radio CRC mode OK. ");
printf("CRC status: %u\n",LoRaWAN._crcStatus);
}
else
{
printf("8.2. Get Radio CRC mode error = %e\n", e);
status = 1;
}
printf("-------------------------------------------------------\n");
return status;
}
//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main (){
setup();
while(1){
loop();
}
return (0);
}
| [
"shijunyanghust@hotmail.com"
] | shijunyanghust@hotmail.com |
45150d0b2237b34acbb5dca81f91df64047c86c6 | cad869c299fc206de8a5573b0acd40168330221e | /tc/core/utils/math.h | 15cf838f254a5e957cacb02eeafedf0210517ad2 | [
"Apache-2.0"
] | permissive | dingobye/TensorComprehensions | ae5fe5b4b3b76c132a4891c5bae206339759780c | 0579904b4c812708cc6157c12dddebd4735bdf28 | refs/heads/master | 2020-03-09T21:14:45.545339 | 2018-04-10T22:51:47 | 2018-04-10T22:51:47 | 129,004,297 | 0 | 0 | Apache-2.0 | 2018-04-10T22:58:07 | 2018-04-10T22:58:06 | null | UTF-8 | C++ | false | false | 1,117 | h | /**
* Copyright (c) 2017-present, Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <exception>
namespace tc {
template <typename V>
typename V::value_type median(V v) {
if (v.size() == 0) {
throw std::out_of_range("median not defined for empty containers");
}
auto n = v.size();
std::nth_element(v.begin(), v.begin() + n / 2, v.end());
if (n % 2 == 1) {
return v.at(n / 2);
}
auto rightElement = v.at(n / 2);
std::nth_element(v.begin(), v.begin() + n / 2 - 1, v.end());
return (v.at(n / 2 - 1) + rightElement) / 2;
}
} // namespace tc
| [
"nicolas.vasilache@gmail.com"
] | nicolas.vasilache@gmail.com |
76747a674b14fed0bbc73a2e21d8d5e8fbb75fa0 | 383513e0f782735e4ffb3e94b214172e3280363a | /Others/Yahoo190209/A.cpp | 2f95e39b8b1076aaf7840f4dd3b760b13ee10460 | [] | no_license | face4/AtCoder | e07c123a604f56901b186c41aa318c93b115d8d1 | 9c81387cb0ee7f669b50d5cc591e05c87670ee36 | refs/heads/master | 2021-06-27T01:07:33.806176 | 2020-11-20T03:47:25 | 2020-11-20T03:47:25 | 137,498,533 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 194 | cpp | #include<iostream>
using namespace std;
int main(){
int n, k;
cin >> n >> k;
if((n+1)/2 >= k) cout << "YES" << endl;
else cout << "NO" << endl;
return 0;
} | [
"s1611361@u.tsukuba.ac.jp"
] | s1611361@u.tsukuba.ac.jp |
5dfb20b2df4c1d65dd29a2c1f54bdb48156b5a2d | c9b02ab1612c8b436c1de94069b139137657899b | /toywar_srv/server/app/logic/RenrenPurchase.h | 76803cb75a7aa9f2831bc5125f2cbe1d1bdee773 | [] | no_license | colinblack/game_server | a7ee95ec4e1def0220ab71f5f4501c9a26ab61ab | a7724f93e0be5c43e323972da30e738e5fbef54f | refs/heads/master | 2020-03-21T19:25:02.879552 | 2020-03-01T08:57:07 | 2020-03-01T08:57:07 | 138,948,382 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 401 | h | #ifndef __LOGIC_PURCHASE_H__
#define __LOGIC_PURCHASE_H__
#include "IPurchase.h"
class CRenrenPurchase : public IPurchase
{
public:
virtual int Purchase(unsigned int uid, short itemId, int count, int price, int cost,
const string &meta, const string &itemUrl, vector<string> &out);
virtual int DeliverGood(unsigned int uid, const map<string, string> ¶ms, vector<string> &out);
};
#endif
| [
"178370407@qq.com"
] | 178370407@qq.com |
8d6506ae66dc64902af5dfef797f60ff97f37c6c | 204cc62cabf9a8ded9994abb6005b3f2d4f8ce9f | /EngineCore/Source/3rdParty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyLink.h | a7b349991518ce141643edacf2fd95a4e8b7c6fc | [] | no_license | ClowReed32/Cthugha-Engine-Demos | 0619afa3b11b5bbc8fa5234ff3a43edc5065d2bc | 313f7cef74e35e2d1dc344d54e6e000180e63e3f | refs/heads/master | 2016-08-13T01:54:13.161904 | 2016-05-08T19:27:57 | 2016-05-08T19:27:57 | 52,268,478 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,446 | h | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2013 Erwin Coumans http://bulletphysics.org
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef BT_MULTIBODY_LINK_H
#define BT_MULTIBODY_LINK_H
#include "LinearMath/btQuaternion.h"
#include "LinearMath/btVector3.h"
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
enum btMultiBodyLinkFlags
{
BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION = 1
};
//#define BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS
#define TEST_SPATIAL_ALGEBRA_LAYER
//
// Various spatial helper functions
//
namespace {
#ifdef TEST_SPATIAL_ALGEBRA_LAYER
struct btSpatialForceVector
{
btVector3 m_topVec, m_bottomVec;
//
btSpatialForceVector() { setZero(); }
btSpatialForceVector(const btVector3 &angular, const btVector3 &linear) : m_topVec(linear), m_bottomVec(angular) {}
btSpatialForceVector(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
{
setValue(ax, ay, az, lx, ly, lz);
}
//
void setVector(const btVector3 &angular, const btVector3 &linear) { m_topVec = linear; m_bottomVec = angular; }
void setValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
{
m_bottomVec.setValue(ax, ay, az); m_topVec.setValue(lx, ly, lz);
}
//
void addVector(const btVector3 &angular, const btVector3 &linear) { m_topVec += linear; m_bottomVec += angular; }
void addValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
{
m_bottomVec[0] += ax; m_bottomVec[1] += ay; m_bottomVec[2] += az;
m_topVec[0] += lx; m_topVec[1] += ly; m_topVec[2] += lz;
}
//
const btVector3 & getLinear() const { return m_topVec; }
const btVector3 & getAngular() const { return m_bottomVec; }
//
void setLinear(const btVector3 &linear) { m_topVec = linear; }
void setAngular(const btVector3 &angular) { m_bottomVec = angular; }
//
void addAngular(const btVector3 &angular) { m_bottomVec += angular; }
void addLinear(const btVector3 &linear) { m_topVec += linear; }
//
void setZero() { m_topVec.setZero(); m_bottomVec.setZero(); }
//
btSpatialForceVector & operator += (const btSpatialForceVector &vec) { m_topVec += vec.m_topVec; m_bottomVec += vec.m_bottomVec; return *this; }
btSpatialForceVector & operator -= (const btSpatialForceVector &vec) { m_topVec -= vec.m_topVec; m_bottomVec -= vec.m_bottomVec; return *this; }
btSpatialForceVector operator - (const btSpatialForceVector &vec) const { return btSpatialForceVector(m_bottomVec - vec.m_bottomVec, m_topVec - vec.m_topVec); }
btSpatialForceVector operator + (const btSpatialForceVector &vec) const { return btSpatialForceVector(m_bottomVec + vec.m_bottomVec, m_topVec + vec.m_topVec); }
btSpatialForceVector operator - () const { return btSpatialForceVector(-m_bottomVec, -m_topVec); }
btSpatialForceVector operator * (const btScalar &s) const { return btSpatialForceVector(s * m_bottomVec, s * m_topVec); }
//btSpatialForceVector & operator = (const btSpatialForceVector &vec) { m_topVec = vec.m_topVec; m_bottomVec = vec.m_bottomVec; return *this; }
};
struct btSpatialMotionVector
{
btVector3 m_topVec, m_bottomVec;
//
btSpatialMotionVector() { setZero(); }
btSpatialMotionVector(const btVector3 &angular, const btVector3 &linear) : m_topVec(angular), m_bottomVec(linear) {}
//
void setVector(const btVector3 &angular, const btVector3 &linear) { m_topVec = angular; m_bottomVec = linear; }
void setValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
{
m_topVec.setValue(ax, ay, az); m_bottomVec.setValue(lx, ly, lz);
}
//
void addVector(const btVector3 &angular, const btVector3 &linear) { m_topVec += linear; m_bottomVec += angular; }
void addValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz)
{
m_topVec[0] += ax; m_topVec[1] += ay; m_topVec[2] += az;
m_bottomVec[0] += lx; m_bottomVec[1] += ly; m_bottomVec[2] += lz;
}
//
const btVector3 & getAngular() const { return m_topVec; }
const btVector3 & getLinear() const { return m_bottomVec; }
//
void setAngular(const btVector3 &angular) { m_topVec = angular; }
void setLinear(const btVector3 &linear) { m_bottomVec = linear; }
//
void addAngular(const btVector3 &angular) { m_topVec += angular; }
void addLinear(const btVector3 &linear) { m_bottomVec += linear; }
//
void setZero() { m_topVec.setZero(); m_bottomVec.setZero(); }
//
btScalar dot(const btSpatialForceVector &b) const
{
return m_bottomVec.dot(b.m_topVec) + m_topVec.dot(b.m_bottomVec);
}
//
template<typename SpatialVectorType>
void cross(const SpatialVectorType &b, SpatialVectorType &out) const
{
out.m_topVec = m_topVec.cross(b.m_topVec);
out.m_bottomVec = m_bottomVec.cross(b.m_topVec) + m_topVec.cross(b.m_bottomVec);
}
template<typename SpatialVectorType>
SpatialVectorType cross(const SpatialVectorType &b) const
{
SpatialVectorType out;
out.m_topVec = m_topVec.cross(b.m_topVec);
out.m_bottomVec = m_bottomVec.cross(b.m_topVec) + m_topVec.cross(b.m_bottomVec);
return out;
}
//
btSpatialMotionVector & operator += (const btSpatialMotionVector &vec) { m_topVec += vec.m_topVec; m_bottomVec += vec.m_bottomVec; return *this; }
btSpatialMotionVector & operator -= (const btSpatialMotionVector &vec) { m_topVec -= vec.m_topVec; m_bottomVec -= vec.m_bottomVec; return *this; }
btSpatialMotionVector & operator *= (const btScalar &s) { m_topVec *= s; m_bottomVec *= s; return *this; }
btSpatialMotionVector operator - (const btSpatialMotionVector &vec) const { return btSpatialMotionVector(m_topVec - vec.m_topVec, m_bottomVec - vec.m_bottomVec); }
btSpatialMotionVector operator + (const btSpatialMotionVector &vec) const { return btSpatialMotionVector(m_topVec + vec.m_topVec, m_bottomVec + vec.m_bottomVec); }
btSpatialMotionVector operator - () const { return btSpatialMotionVector(-m_topVec, -m_bottomVec); }
btSpatialMotionVector operator * (const btScalar &s) const { return btSpatialMotionVector(s * m_topVec, s * m_bottomVec); }
};
struct btSymmetricSpatialDyad
{
btMatrix3x3 m_topLeftMat, m_topRightMat, m_bottomLeftMat;
//
btSymmetricSpatialDyad() { setIdentity(); }
btSymmetricSpatialDyad(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat) { setMatrix(topLeftMat, topRightMat, bottomLeftMat); }
//
void setMatrix(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat)
{
m_topLeftMat = topLeftMat;
m_topRightMat = topRightMat;
m_bottomLeftMat = bottomLeftMat;
}
//
void addMatrix(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat)
{
m_topLeftMat += topLeftMat;
m_topRightMat += topRightMat;
m_bottomLeftMat += bottomLeftMat;
}
//
void setIdentity() { m_topLeftMat.setIdentity(); m_topRightMat.setIdentity(); m_bottomLeftMat.setIdentity(); }
//
btSymmetricSpatialDyad & operator -= (const btSymmetricSpatialDyad &mat)
{
m_topLeftMat -= mat.m_topLeftMat;
m_topRightMat -= mat.m_topRightMat;
m_bottomLeftMat -= mat.m_bottomLeftMat;
return *this;
}
//
btSpatialForceVector operator * (const btSpatialMotionVector &vec)
{
return btSpatialForceVector(m_bottomLeftMat * vec.m_topVec + m_topLeftMat.transpose() * vec.m_bottomVec, m_topLeftMat * vec.m_topVec + m_topRightMat * vec.m_bottomVec);
}
};
struct btSpatialTransformationMatrix
{
btMatrix3x3 m_rotMat; //btMatrix3x3 m_trnCrossMat;
btVector3 m_trnVec;
//
enum eOutputOperation
{
None = 0,
Add = 1,
Subtract = 2
};
//
template<typename SpatialVectorType>
void transform( const SpatialVectorType &inVec,
SpatialVectorType &outVec,
eOutputOperation outOp = None)
{
if(outOp == None)
{
outVec.m_topVec = m_rotMat * inVec.m_topVec;
outVec.m_bottomVec = -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec;
}
else if(outOp == Add)
{
outVec.m_topVec += m_rotMat * inVec.m_topVec;
outVec.m_bottomVec += -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec;
}
else if(outOp == Subtract)
{
outVec.m_topVec -= m_rotMat * inVec.m_topVec;
outVec.m_bottomVec -= -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec;
}
}
template<typename SpatialVectorType>
void transformRotationOnly( const SpatialVectorType &inVec,
SpatialVectorType &outVec,
eOutputOperation outOp = None)
{
if(outOp == None)
{
outVec.m_topVec = m_rotMat * inVec.m_topVec;
outVec.m_bottomVec = m_rotMat * inVec.m_bottomVec;
}
else if(outOp == Add)
{
outVec.m_topVec += m_rotMat * inVec.m_topVec;
outVec.m_bottomVec += m_rotMat * inVec.m_bottomVec;
}
else if(outOp == Subtract)
{
outVec.m_topVec -= m_rotMat * inVec.m_topVec;
outVec.m_bottomVec -= m_rotMat * inVec.m_bottomVec;
}
}
template<typename SpatialVectorType>
void transformInverse( const SpatialVectorType &inVec,
SpatialVectorType &outVec,
eOutputOperation outOp = None)
{
if(outOp == None)
{
outVec.m_topVec = m_rotMat.transpose() * inVec.m_topVec;
outVec.m_bottomVec = m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec));
}
else if(outOp == Add)
{
outVec.m_topVec += m_rotMat.transpose() * inVec.m_topVec;
outVec.m_bottomVec += m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec));
}
else if(outOp == Subtract)
{
outVec.m_topVec -= m_rotMat.transpose() * inVec.m_topVec;
outVec.m_bottomVec -= m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec));
}
}
template<typename SpatialVectorType>
void transformInverseRotationOnly( const SpatialVectorType &inVec,
SpatialVectorType &outVec,
eOutputOperation outOp = None)
{
if(outOp == None)
{
outVec.m_topVec = m_rotMat.transpose() * inVec.m_topVec;
outVec.m_bottomVec = m_rotMat.transpose() * inVec.m_bottomVec;
}
else if(outOp == Add)
{
outVec.m_topVec += m_rotMat.transpose() * inVec.m_topVec;
outVec.m_bottomVec += m_rotMat.transpose() * inVec.m_bottomVec;
}
else if(outOp == Subtract)
{
outVec.m_topVec -= m_rotMat.transpose() * inVec.m_topVec;
outVec.m_bottomVec -= m_rotMat.transpose() * inVec.m_bottomVec;
}
}
void transformInverse( const btSymmetricSpatialDyad &inMat,
btSymmetricSpatialDyad &outMat,
eOutputOperation outOp = None)
{
const btMatrix3x3 r_cross( 0, -m_trnVec[2], m_trnVec[1],
m_trnVec[2], 0, -m_trnVec[0],
-m_trnVec[1], m_trnVec[0], 0);
if(outOp == None)
{
outMat.m_topLeftMat = m_rotMat.transpose() * ( inMat.m_topLeftMat - inMat.m_topRightMat * r_cross ) * m_rotMat;
outMat.m_topRightMat = m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat;
outMat.m_bottomLeftMat = m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat;
}
else if(outOp == Add)
{
outMat.m_topLeftMat += m_rotMat.transpose() * ( inMat.m_topLeftMat - inMat.m_topRightMat * r_cross ) * m_rotMat;
outMat.m_topRightMat += m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat;
outMat.m_bottomLeftMat += m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat;
}
else if(outOp == Subtract)
{
outMat.m_topLeftMat -= m_rotMat.transpose() * ( inMat.m_topLeftMat - inMat.m_topRightMat * r_cross ) * m_rotMat;
outMat.m_topRightMat -= m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat;
outMat.m_bottomLeftMat -= m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat;
}
}
template<typename SpatialVectorType>
SpatialVectorType operator * (const SpatialVectorType &vec)
{
SpatialVectorType out;
transform(vec, out);
return out;
}
};
template<typename SpatialVectorType>
void symmetricSpatialOuterProduct(const SpatialVectorType &a, const SpatialVectorType &b, btSymmetricSpatialDyad &out)
{
//output op maybe?
out.m_topLeftMat = outerProduct(a.m_topVec, b.m_bottomVec);
out.m_topRightMat = outerProduct(a.m_topVec, b.m_topVec);
out.m_topLeftMat = outerProduct(a.m_bottomVec, b.m_bottomVec);
//maybe simple a*spatTranspose(a) would be nicer?
}
template<typename SpatialVectorType>
btSymmetricSpatialDyad symmetricSpatialOuterProduct(const SpatialVectorType &a, const SpatialVectorType &b)
{
btSymmetricSpatialDyad out;
out.m_topLeftMat = outerProduct(a.m_topVec, b.m_bottomVec);
out.m_topRightMat = outerProduct(a.m_topVec, b.m_topVec);
out.m_bottomLeftMat = outerProduct(a.m_bottomVec, b.m_bottomVec);
return out;
//maybe simple a*spatTranspose(a) would be nicer?
}
#endif
}
//
// Link struct
//
struct btMultibodyLink
{
BT_DECLARE_ALIGNED_ALLOCATOR();
btScalar m_mass; // mass of link
btVector3 m_inertia; // inertia of link (local frame; diagonal)
int m_parent; // index of the parent link (assumed to be < index of this link), or -1 if parent is the base link.
btQuaternion m_zeroRotParentToThis; // rotates vectors in parent-frame to vectors in local-frame (when q=0). constant.
btVector3 m_dVector; // vector from the inboard joint pos to this link's COM. (local frame.) constant. set for revolute joints only.
// m_eVector is constant, but depends on the joint type
// prismatic: vector from COM of parent to COM of this link, WHEN Q = 0. (local frame.)
// revolute: vector from parent's COM to the pivot point, in PARENT's frame.
btVector3 m_eVector;
btSpatialMotionVector m_absFrameTotVelocity, m_absFrameLocVelocity;
enum eFeatherstoneJointType
{
eRevolute = 0,
ePrismatic = 1,
eSpherical = 2,
#ifdef BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS
ePlanar = 3,
#endif
eInvalid
};
eFeatherstoneJointType m_jointType;
int m_dofCount, m_posVarCount; //redundant but handy
// "axis" = spatial joint axis (Mirtich Defn 9 p104). (expressed in local frame.) constant.
// for prismatic: m_axesTop[0] = zero;
// m_axesBottom[0] = unit vector along the joint axis.
// for revolute: m_axesTop[0] = unit vector along the rotation axis (u);
// m_axesBottom[0] = u cross m_dVector (i.e. COM linear motion due to the rotation at the joint)
//
// for spherical: m_axesTop[0][1][2] (u1,u2,u3) form a 3x3 identity matrix (3 rotation axes)
// m_axesBottom[0][1][2] cross u1,u2,u3 (i.e. COM linear motion due to the rotation at the joint)
//
// for planar: m_axesTop[0] = unit vector along the rotation axis (u); defines the plane of motion
// m_axesTop[1][2] = zero
// m_axesBottom[0] = zero
// m_axesBottom[1][2] = unit vectors along the translational axes on that plane
#ifndef TEST_SPATIAL_ALGEBRA_LAYER
btVector3 m_axesTop[6];
btVector3 m_axesBottom[6];
void setAxisTop(int dof, const btVector3 &axis) { m_axesTop[dof] = axis; }
void setAxisBottom(int dof, const btVector3 &axis) { m_axesBottom[dof] = axis; }
void setAxisTop(int dof, const btScalar &x, const btScalar &y, const btScalar &z) { m_axesTop[dof].setValue(x, y, z); }
void setAxisBottom(int dof, const btScalar &x, const btScalar &y, const btScalar &z) { m_axesBottom[dof].setValue(x, y, z); }
const btVector3 & getAxisTop(int dof) const { return m_axesTop[dof]; }
const btVector3 & getAxisBottom(int dof) const { return m_axesBottom[dof]; }
#else
btSpatialMotionVector m_axes[6];
void setAxisTop(int dof, const btVector3 &axis) { m_axes[dof].m_topVec = axis; }
void setAxisBottom(int dof, const btVector3 &axis) { m_axes[dof].m_bottomVec = axis; }
void setAxisTop(int dof, const btScalar &x, const btScalar &y, const btScalar &z) { m_axes[dof].m_topVec.setValue(x, y, z); }
void setAxisBottom(int dof, const btScalar &x, const btScalar &y, const btScalar &z) { m_axes[dof].m_bottomVec.setValue(x, y, z); }
const btVector3 & getAxisTop(int dof) const { return m_axes[dof].m_topVec; }
const btVector3 & getAxisBottom(int dof) const { return m_axes[dof].m_bottomVec; }
#endif
int m_dofOffset, m_cfgOffset;
btQuaternion m_cachedRotParentToThis; // rotates vectors in parent frame to vectors in local frame
btVector3 m_cachedRVector; // vector from COM of parent to COM of this link, in local frame.
btVector3 m_appliedForce; // In WORLD frame
btVector3 m_appliedTorque; // In WORLD frame
btScalar m_jointPos[7];
btScalar m_jointTorque[6]; //TODO
class btMultiBodyLinkCollider* m_collider;
int m_flags;
// ctor: set some sensible defaults
btMultibodyLink()
: m_mass(1),
m_parent(-1),
m_zeroRotParentToThis(1, 0, 0, 0),
m_cachedRotParentToThis(1, 0, 0, 0),
m_collider(0),
m_flags(0),
m_dofCount(0),
m_posVarCount(0),
m_jointType(btMultibodyLink::eInvalid)
{
m_inertia.setValue(1, 1, 1);
setAxisTop(0, 0., 0., 0.);
setAxisBottom(0, 1., 0., 0.);
m_dVector.setValue(0, 0, 0);
m_eVector.setValue(0, 0, 0);
m_cachedRVector.setValue(0, 0, 0);
m_appliedForce.setValue( 0, 0, 0);
m_appliedTorque.setValue(0, 0, 0);
//
m_jointPos[0] = m_jointPos[1] = m_jointPos[2] = m_jointPos[4] = m_jointPos[5] = m_jointPos[6] = 0.f;
m_jointPos[3] = 1.f; //"quat.w"
m_jointTorque[0] = m_jointTorque[1] = m_jointTorque[2] = m_jointTorque[3] = m_jointTorque[4] = m_jointTorque[5] = 0.f;
}
// routine to update m_cachedRotParentToThis and m_cachedRVector
void updateCache()
{
//multidof
if (m_jointType == eRevolute)
{
m_cachedRotParentToThis = btQuaternion(getAxisTop(0),-m_jointPos[0]) * m_zeroRotParentToThis;
m_cachedRVector = m_dVector + quatRotate(m_cachedRotParentToThis,m_eVector);
} else
{
// m_cachedRotParentToThis never changes, so no need to update
m_cachedRVector = m_eVector + m_jointPos[0] * getAxisBottom(0);
}
}
void updateCacheMultiDof(btScalar *pq = 0)
{
btScalar *pJointPos = (pq ? pq : &m_jointPos[0]);
switch(m_jointType)
{
case eRevolute:
{
m_cachedRotParentToThis = btQuaternion(getAxisTop(0),-pJointPos[0]) * m_zeroRotParentToThis;
m_cachedRVector = m_dVector + quatRotate(m_cachedRotParentToThis,m_eVector);
break;
}
case ePrismatic:
{
// m_cachedRotParentToThis never changes, so no need to update
m_cachedRVector = m_eVector + pJointPos[0] * getAxisBottom(0);
break;
}
case eSpherical:
{
m_cachedRotParentToThis = btQuaternion(pJointPos[0], pJointPos[1], pJointPos[2], -pJointPos[3]) * m_zeroRotParentToThis;
m_cachedRVector = m_dVector + quatRotate(m_cachedRotParentToThis,m_eVector);
break;
}
#ifdef BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS
case ePlanar:
{
m_cachedRotParentToThis = btQuaternion(getAxisTop(0),-pJointPos[0]) * m_zeroRotParentToThis;
m_cachedRVector = quatRotate(btQuaternion(getAxisTop(0),-pJointPos[0]), pJointPos[1] * m_axesBottom[1] + pJointPos[2] * m_axesBottom[2]) + quatRotate(m_cachedRotParentToThis,m_eVector);
break;
}
#endif
}
}
};
#endif //BT_MULTIBODY_LINK_H
| [
"vash3.2@gmail.com"
] | vash3.2@gmail.com |
e22be621d2a121071268991a8ecc9a38014f5929 | dc8eb22a8b510b605f8c1caf4282b06e181a8d2f | /GeekDb/GeekDb/GeekDbManager.h | 0bac98837fcbfa8c7ccb259f66ca4344c8314db3 | [] | no_license | anjingxing/GeekBand-CPP-1501-SampleProject | 4500aef0effb1207daa1bc82b20c6fac8566894c | 609d7b8c4071718b71f8cecb46f1b4f16b231659 | refs/heads/master | 2020-09-23T19:02:45.895980 | 2015-09-22T03:08:00 | 2015-09-22T03:08:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,365 | h | //*************************************************
// Module: GeekDbManager.h
// Notices: Copyright (c) 2015 Zhang Wenjie
//*************************************************
#pragma once
#include "GeekDb.h"
#include "GeekSequenceDb.h"
#include "GeekUtils.h"
#include "GeekErrorCode.h"
#include <string>
#include <map>
#include <algorithm>
namespace geek
{
//
// Manages all geek database created in memory.
//
class GeekDbManager
{
public:
GeekDbManager(void) { }
~GeekDbManager(void) { }
public:
template <typename TConcrete>
GeekResult CreateDatabase(
INPARAM const std::wstring& wszName
);
//
// Load database into memory from file system.
//
template <typename TConcrete>
GeekResult LoadDatabase(
INPARAM const std::wstring& wszFileName,
OUTPARAM std::wstring& wszName
);
//
// Get the size the database by the given name.
//
const size_t GetDatabaseSize(
INPARAM const std::wstring& wszName
);
GeekResult InsertDatabase(
INPARAM const std::wstring& wszName,
INPARAM const GeekKeyValue& entry
);
//
// Batch insert
//
GeekResult InsertDatabase(
INPARAM const std::wstring& wszName,
INPARAM const std::vector<GeekKeyValue>& entries
);
GeekResult UpdateDatabase(
INPARAM const std::wstring& wszName,
INPARAM const GeekKeyValue& entry
);
GeekResult DeleteDatabase(
INPARAM const std::wstring& wszName,
INPARAM const std::wstring& wszKey
);
GeekResult DisposeDatabase(INPARAM const std::wstring& wszName);
GeekResult DumpDatabase(
INPARAM const std::wstring& wszName,
INPARAM const std::wstring& wszFileName
);
GeekResult TraverseDatabase(INPARAM const std::wstring& wszName);
private:
inline GeekDb* GetDatabaseByName(const std::wstring& wszName)
{
CollectionIterator it = m_DbCollection.find(wszName);
if (it == m_DbCollection.end())
return NULL;
return (*it).second;
}
private:
typedef std::map<std::wstring, GeekDb*>::iterator CollectionIterator;
std::map<std::wstring, GeekDb*> m_DbCollection;
};
template <typename TConcrete>
GeekResult GeekDbManager::CreateDatabase(
INPARAM const std::wstring& wszName)
{
typedef typename GeekDbTraits<TConcrete>::Database Database;
GeekDbMetadata metadata;
metadata.wszName = wszName;
Database* pdb = new Database(metadata);
if (pdb == NULL)
return GEEK_ERROR_OUTOFMEMORY;
m_DbCollection.insert(std::make_pair(wszName, pdb));
return GEEK_SUCCESS;
}
template <typename TConcrete>
GeekResult GeekDbManager::LoadDatabase(
INPARAM const std::wstring & wszFileName,
OUTPARAM std::wstring& wszName)
{
if (geek::IsNullOrEmpty(wszFileName))
return GEEK_ERROR_INVALIDPARAM;
if (!geek::IsFileExists(wszFileName))
return GEEK_ERROR_FILENOTFOUND;
typedef typename GeekDbTraits<TConcrete>::Database Database;
Database* pdb = new Database(GeekDbMetadata());
if (pdb == NULL)
return GEEK_ERROR_OUTOFMEMORY;
GeekResult result = pdb->LoadKeyValues(wszFileName, wszName);
// does the database name already exists ?
CollectionIterator it = m_DbCollection.find(wszName);
if (it != m_DbCollection.end())
{
// already exists, replace with the loaded db.
m_DbCollection[wszName] = pdb;
}
else
{
// add the loaded db.
m_DbCollection.insert(std::make_pair(wszName, pdb));
}
return result;
}
} | [
"wjzhangb@hotmail.com"
] | wjzhangb@hotmail.com |
5ab7678bede820234b981d6d5113337d7c6c78e4 | 6793bf4e965d9b6d4bd3d210585a39069369ed27 | /old (class)/pidlib.h | a3f1ddf9b76204575469ccad490f5efb80998721 | [
"MIT"
] | permissive | ryomakawakami/pidlib | 5bb652dfaacc23f10631c85bd118ed90d6d141c4 | 93610c57ae6e56cc6a0bf68f45c5f7d3d8c658ac | refs/heads/master | 2020-04-12T20:26:28.627461 | 2019-02-11T21:59:22 | 2019-02-11T21:59:22 | 162,736,229 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,374 | h | #ifndef PIDLIB
#define PIDLIB
// Returns system time in ms
long getTime() {
return(nPgmTime);
}
// PID class
// lastTime stores time of previous calculation
// kP, kI, kD, kF are constants for PID
// lastError stores the last value of the error
// sigma stores the total error
class PID {
public:
PID PID(float p, float i, float d, float f);
void setConstants(float p, float i, float d, float f);
float calculate(float target, float sensorValue, float range = 10000);
private:
long lastTime;
float kP, kI, kD, kF;
float lastError;
float sigma;
};
// PID object constructor
// lastTime set to current time
// kP, kI, kD, kF set to inputted values
// lastError, sigma set to 0
PID::PID(float p, float i, float d, float f) {
lastTime = getTime();
kP = p;
kI = i;
kD = d;
kF = f;
lastError = 0;
sigma = 0;
}
// PID function setConstants
// Allows user to input kP, kI, kD and initializes other variables
// lastTime set to current time
// kP, kI, kD, kF set to inputted values
// lastError, sigma set to 0
void PID::setConstants(float p, float i, float d, float f) {
lastTime = getTime();
kP = p;
kI = i;
kD = d;
kF = f;
lastError = 0;
sigma = 0;
}
// PID function calculate
// Calculates control loop output
// Integral range default is a large value
float PID::calculate(float target, float sensorValue, float range = 10000) {
// Declare variables
float deltaTime, error, derivative, output;
// Find change in time and store current
deltaTime = (float)(getTime() - lastTime) / 1000.0;
lastTime = getTime();
// Calculate error (P)
error = target - sensorValue;
// Calculate sigma (I)
sigma += error * deltaTime;
// Reset sigma if outside of integral range
if(abs(error) > range) {
sigma = 0;
}
// Also reset if robot shoots over
else if(target > 0) {
if(error < 0) {
sigma = 0;
}
}
else {
if(error > 0) {
sigma = 0;
}
}
// Calculate derivative (D)
// Change in value over change in time and store current
derivative = (error - lastError) / deltaTime;
lastError = error;
// Calculate output
output = kP * error + kI * sigma + kD * derivative + kF * target;
return output;
}
#endif | [
"ryomakwkm@gmail.com"
] | ryomakwkm@gmail.com |
2af3ac9f4786d32eb5b929e6d0e24c07c9764267 | 60bb67415a192d0c421719de7822c1819d5ba7ac | /blazetest/src/mathtest/smatsmatschur/HCaMCb.cpp | 91d587a00975da476dc1e46ffa6d86665f5599ac | [
"BSD-3-Clause"
] | permissive | rtohid/blaze | 48decd51395d912730add9bc0d19e617ecae8624 | 7852d9e22aeb89b907cb878c28d6ca75e5528431 | refs/heads/master | 2020-04-16T16:48:03.915504 | 2018-12-19T20:29:42 | 2018-12-19T20:29:42 | 165,750,036 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,185 | cpp | //=================================================================================================
/*!
// \file src/mathtest/smatsmatschur/HCaMCb.cpp
// \brief Source file for the HCaMCb sparse matrix/sparse matrix Schur product math test
//
// Copyright (C) 2012-2018 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. 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 names of the Blaze development group 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.
*/
//=================================================================================================
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <cstdlib>
#include <iostream>
#include <blaze/math/CompressedMatrix.h>
#include <blaze/math/HermitianMatrix.h>
#include <blazetest/mathtest/Creator.h>
#include <blazetest/mathtest/smatsmatschur/OperationTest.h>
#include <blazetest/system/MathTest.h>
//=================================================================================================
//
// MAIN FUNCTION
//
//=================================================================================================
//*************************************************************************************************
int main()
{
std::cout << " Running 'HCaMCb'..." << std::endl;
using blazetest::mathtest::NumericA;
using blazetest::mathtest::NumericB;
try
{
// Matrix type definitions
using HCa = blaze::HermitianMatrix< blaze::CompressedMatrix<NumericA> >;
using MCb = blaze::CompressedMatrix<NumericB>;
// Creator type definitions
using CHCa = blazetest::Creator<HCa>;
using CMCb = blazetest::Creator<MCb>;
// Running tests with small matrices
for( size_t i=0UL; i<=6UL; ++i ) {
for( size_t j=0UL; j<=i*i; ++j ) {
for( size_t k=0UL; k<=i*i; ++k ) {
RUN_SMATSMATSCHUR_OPERATION_TEST( CHCa( i, j ), CMCb( i, i, k ) );
}
}
}
// Running tests with large matrices
RUN_SMATSMATSCHUR_OPERATION_TEST( CHCa( 67UL, 7UL ), CMCb( 67UL, 67UL, 13UL ) );
RUN_SMATSMATSCHUR_OPERATION_TEST( CHCa( 128UL, 16UL ), CMCb( 128UL, 128UL, 8UL ) );
}
catch( std::exception& ex ) {
std::cerr << "\n\n ERROR DETECTED during sparse matrix/sparse matrix Schur product:\n"
<< ex.what() << "\n";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//*************************************************************************************************
| [
"klaus.iglberger@gmail.com"
] | klaus.iglberger@gmail.com |
2af1b5a6d111c9a1fdbff0a4bc808eb04e8410fb | 8b073cfaf9516347064a6801eff54baad9c8ea1d | /TheGoogle/avlnode.h | 18c470d7442cc669d546ce9589cdc2cdfe4fdce5 | [] | no_license | ashleyisles/TheGoogle | 4cd045a8fe0a54c8822853de1458d4d1c9448b44 | afe0caca53c9a7a3aa67ee2a73999117f5d517e2 | refs/heads/master | 2021-01-23T09:33:53.386882 | 2014-11-24T02:33:36 | 2014-11-24T02:33:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 475 | h | #ifndef AVLNODE_H
#define AVLNODE_H
#include <iostream>
#include <fstream>
#include <cstring>
#include <iomanip>
using namespace std;
class AVLNode
{
friend class AVLIndex;
private:
AVLNode* left;
AVLNode* right;
char* word;
int height;
int* Ids;
public:
AVLNode(char* word, int ID);
AVLNode(int ID);
AVLNode* addID(AVLNode* &node, int ID);
void IncreaseArraySize(AVLNode* &node, int i);
~AVLNode();
};
#endif // AVLNODE_H
| [
"Redson@smu.edu"
] | Redson@smu.edu |
673e5eba5370e571f945e948c4ec635e0b7f30bc | e3aefe4afb1a8ea04777202eb5a7792d8da8f844 | /samples/vst/programchange/source/plugentry.cpp | 759081b70c7bbbc8b4e64084b95a4bedebe2cac1 | [] | no_license | eriser/vst3_public_sdk | 570101bf99000bf3fdc6d5712770edbe2ddebc1a | abcdb402a2f09b88d432a392301a5a3c7a72d6de | refs/heads/master | 2021-08-14T10:09:48.094691 | 2017-11-15T10:39:13 | 2017-11-15T10:39:13 | 110,819,785 | 1 | 0 | null | 2017-11-15T10:33:25 | 2017-11-15T10:33:25 | null | UTF-8 | C++ | false | false | 4,845 | cpp | //------------------------------------------------------------------------
// Project : VST SDK
//
// Category : Examples
// Filename : public.sdk/samples/vst/XX/source/plugentry.cpp
// Created by : Steinberg, 02/2016
// Description : Plug-in Example for VST SDK 3.x using ProgramChange parameter
//
//-----------------------------------------------------------------------------
// LICENSE
// (c) 2017, Steinberg Media Technologies GmbH, All Rights Reserved
//-----------------------------------------------------------------------------
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * 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.
// * Neither the name of the Steinberg Media Technologies 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 OWNER 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.
//-----------------------------------------------------------------------------
#include "plug.h"
#include "plugcontroller.h"
#include "plugcids.h" // for class ids
#include "version.h" // for versioning
#include "public.sdk/source/main/pluginfactoryvst3.h"
#define stringPluginName "Test Program Change"
//------------------------------------------------------------------------
// Module init/exit
//------------------------------------------------------------------------
//------------------------------------------------------------------------
// called after library was loaded
bool InitModule ()
{
return true;
}
//------------------------------------------------------------------------
// called after library is unloaded
bool DeinitModule ()
{
return true;
}
using namespace Steinberg;
using namespace Steinberg::Vst;
//------------------------------------------------------------------------
// VST Plug-in Entry
//------------------------------------------------------------------------
// Windows: do not forget to include a .def file in your project to export
// GetPluginFactory function!
//------------------------------------------------------------------------
BEGIN_FACTORY_DEF ("Steinberg Media Technologies",
"http://www.steinberg.net",
"mailto:info@steinberg.de")
//---First Plug-in included in this factory-------
// its kVstAudioEffectClass component
DEF_CLASS2 (INLINE_UID_FROM_FUID(PlugProcessorUID),
PClassInfo::kManyInstances, // cardinality
kVstAudioEffectClass, // the component category (do not changed this)
stringPluginName, // here the Plug-in name (to be changed)
Vst::kDistributable, // means that component and controller could be distributed on different computers
"Fx", // Subcategory for this Plug-in (to be changed)
FULL_VERSION_STR, // Plug-in version (to be changed)
kVstVersionString, // the VST 3 SDK version (do not changed this, use always this define)
Steinberg::Vst::Plug::createInstance) // function pointer called when this component should be instantiated
// its kVstComponentControllerClass component
DEF_CLASS2 (INLINE_UID_FROM_FUID (PlugControllerUID),
PClassInfo::kManyInstances, // cardinality
kVstComponentControllerClass,// the Controller category (do not changed this)
stringPluginName "Controller", // controller name (could be the same than component name)
0, // not used here
"", // not used here
FULL_VERSION_STR, // Plug-in version (to be changed)
kVstVersionString, // the VST 3 SDK version (do not changed this, use always this define)
Steinberg::Vst::PlugController::createInstance)// function pointer called when this component should be instantiated
END_FACTORY
| [
"scheffle@users.noreply.github.com"
] | scheffle@users.noreply.github.com |
2cc3af63676e21f55baa50e3aad766c03653f844 | 1e56bb6ce1a3ebe11d1a892d52a1485bfa32ed01 | /src/test/canonical_tests.cpp | d5c3a1d52e7964cbe3ce58c62e42e68c563371a8 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | jeepman4403/VERGE-1 | 052d8d2da8748e5209dcbe56950f8e80ff5f7d26 | ee21439c1c826dd7da5e9ce57a50616042e82ae0 | refs/heads/master | 2020-03-28T22:23:42.318647 | 2018-09-18T12:46:03 | 2018-09-18T12:46:03 | 149,229,298 | 1 | 0 | MIT | 2018-09-18T04:32:16 | 2018-09-18T04:32:16 | null | UTF-8 | C++ | false | false | 2,438 | cpp | //
// Unit tests for canonical signatures
#include "json/json_spirit_writer_template.h"
#include <boost/test/unit_test.hpp>
#include <openssl/ecdsa.h>
#include "key.h"
#include "script.h"
#include "util.h"
using namespace std;
using namespace json_spirit;
// In script_tests.cpp
extern Array read_json(const std::string& filename);
BOOST_AUTO_TEST_SUITE(canonical_tests)
// OpenSSL-based test for canonical signature (without test for hashtype byte)
bool static IsCanonicalSignature_OpenSSL_inner(const std::vector<unsigned char>& vchSig)
{
if (vchSig.size() == 0)
return false;
const unsigned char *input = &vchSig[0];
ECDSA_SIG *psig = NULL;
d2i_ECDSA_SIG(&psig, &input, vchSig.size());
if (psig == NULL)
return false;
unsigned char buf[256];
unsigned char *pbuf = buf;
unsigned int nLen = i2d_ECDSA_SIG(psig, NULL);
if (nLen != vchSig.size()) {
ECDSA_SIG_free(psig);
return false;
}
nLen = i2d_ECDSA_SIG(psig, &pbuf);
ECDSA_SIG_free(psig);
return (memcmp(&vchSig[0], &buf[0], nLen) == 0);
}
// OpenSSL-based test for canonical signature
bool static IsCanonicalSignature_OpenSSL(const std::vector<unsigned char> &vchSignature) {
if (vchSignature.size() < 1)
return false;
if (vchSignature.size() > 127)
return false;
if (vchSignature[vchSignature.size() - 1] & 0x7C)
return false;
std::vector<unsigned char> vchSig(vchSignature);
vchSig.pop_back();
if (!IsCanonicalSignature_OpenSSL_inner(vchSig))
return false;
return true;
}
BOOST_AUTO_TEST_CASE(script_canon)
{
Array tests = read_json("sig_canonical.json");
BOOST_FOREACH(Value &tv, tests) {
string test = tv.get_str();
if (IsHex(test)) {
std::vector<unsigned char> sig = ParseHex(test);
BOOST_CHECK_MESSAGE(IsCanonicalSignature(sig), test);
BOOST_CHECK_MESSAGE(IsCanonicalSignature_OpenSSL(sig), test);
}
}
}
BOOST_AUTO_TEST_CASE(script_noncanon)
{
Array tests = read_json("sig_noncanonical.json");
BOOST_FOREACH(Value &tv, tests) {
string test = tv.get_str();
if (IsHex(test)) {
std::vector<unsigned char> sig = ParseHex(test);
BOOST_CHECK_MESSAGE(!IsCanonicalSignature(sig), test);
BOOST_CHECK_MESSAGE(!IsCanonicalSignature_OpenSSL(sig), test);
}
}
}
BOOST_AUTO_TEST_SUITE_END() | [
"justinvforvendetta@gmail.com"
] | justinvforvendetta@gmail.com |
b91f1ffa46310f267d639297bb27bb71b4c69071 | 5272d749992015821c643f8e1a932ae1b12888d2 | /include/solace/path.hpp | 99146c992da792b0874df21bfaf1f168aae6e08c | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | puttareddy/libsolace | 7beb82b3b1d805e550722428d0ae473188cd0946 | 3177af7a7f7ef78b5e07dd6a9e3e3029108efa44 | refs/heads/master | 2021-08-15T00:32:36.784716 | 2017-11-17T02:25:43 | 2017-11-17T02:25:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,914 | hpp | /*
* Copyright 2016 Ivan Ryabov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*******************************************************************************
* libSolace: Hierarchical path object
* @file solace/path.hpp
* @author $LastChangedBy$
* @date $LastChangedDate$
* @brief Immutable hierarchical Path class
* ID: $Id$
******************************************************************************/
#pragma once
#ifndef SOLACE_PATH_HPP
#define SOLACE_PATH_HPP
#include "solace/string.hpp"
#include "solace/array.hpp"
namespace Solace {
/** Hierarchical path class - the kind used by File system, but not exactly
* Path is an ordered sequence of strings/names that can be represented by a string,
* e.g Formattable and Parsable object.
*
* Examples of Paths (first 3 with the same '/' as a delimiter):
* * File system path string: /etc/config.json
* * URL path component: /webapp/action/index.html
* * Tree element path: <root>/node x/taget_node
* * Web host name also a path: www.blah.example.com
* * Java package name: org.java.AwesomePackages
*
* Note: that path object is designed to be immutable, e.g it cannot be changed once created,
* It can be appended to / subtracted from - creating a new object (kind of like a linked list).
* Being immutable means that any such addition or subtraction will produce a new object.
*
* Note: Path is an abstraction and is not designed to be compatible with
* the underlying filesystem representation of a file path.
* Wherever possible file objects can be created from a file system path,
* but no direct compatibility is designed.
* This also implies that functions line noramalize don't do file system travesal,
* but operate on path string components only.
*/
class Path :
public IComparable<Path>,
public Iterable<Path, String>,
public IFormattable {
public:
typedef Array<String>::size_type size_type;
typedef Array<String>::const_iterator const_iterator;
public: // Static methods
/**
* Default delimiter used form string representation of the path
* Note: might be different from platform delimiter
*/
static const String Delimiter;
/**
* Root path object
*/
static const Path Root;
/**
* Join paths objects into a single path
*/
static Path join(const Path& lhs, const Path& rhs) {
return lhs.join(rhs);
}
static Path join(const Path& lhs, const String& rhs) {
return lhs.join(rhs);
}
static Path join(std::initializer_list<Path> paths);
static Path join(std::initializer_list<String> paths);
/**
* Parse a path object from a string.
*
* @param str A string to parse
* @param delim A delimiter used to separate path components
* @return Parsed path object
*
* TODO: Parse family of functions should return Result<Path, ParseError>
*/
static Path parse(const String& str, const String& delim = Delimiter);
public: // Object construction
virtual ~Path() noexcept = default;
/** Construct an empty path */
Path(): _components() {
// No-op
}
/** Construct path to be a copy of the given one */
Path(const Path& p): _components(p._components) {
// No-op
}
/** Construct an object by moving content from a given */
Path(Path&& p) noexcept: _components(std::move(p._components)) {
// No-op
}
/**
* Construct the path object from a collection of String components
* @param array A collection of string components forming the path
*/
Path(const Array<String>& array): _components(array) {
// No-op
}
/**
* Move-Construct the path object from a collection of String components
* @param array A collection of string components forming the path
*/
Path(Array<String>&& array): _components(std::move(array)) {
// No-op
}
/**
* Construct the path object from a single string component
*
* @note The string is is parsed into component, please use Path::parse
*/
Path(const String& str): _components({str}) {
// No-op
}
Path(const IFormattable& src): Path(src.toString()) {
// No-op
}
Path(const std::initializer_list<Path>& components): Path(Path::join(components)) {
// No-op
}
Path(const std::initializer_list<String>& components): _components(components) {
// No-op
}
public: // Operation
Path& swap(Path& rhs) noexcept {
_components.swap(rhs._components);
return (*this);
}
/**
* Move assignement.
* @param rhs An object to move content from.
* @return A reference to this.
*/
Path& operator= (Path&& rhs) noexcept {
return swap(rhs);
}
/** Test if the path is empty.
*
* Path is empty only when it has no components.
* @return True if the path object is empty.
*/
bool empty() const noexcept {
return _components.empty();
}
/** Test if path is not empty.
* @return True if this path is not an empty object.
*/
explicit operator bool() const {
return !empty();
}
/**
* Test if the path is absolute.
*
* Asbolute path is the one that starts with the root.
* @return True if the path object represents absolute path
*/
bool isAbsolute() const noexcept;
/**
* Test if the path is relative.
*
* Relative path is the one that doe not starts with the root.
* @return True if the path object represents relative path
*/
bool isRelative() const noexcept;
/**
* Get the lenght of the string representation of this path.
*
* @note: To get the number of components, please @see getComponentsCount
* @return Size of the string representation of the path in characters.
*/
String::size_type length(const String& delim = Delimiter) const noexcept;
//--------------------------------------------------------------------------
// --- Relational collection operations
//--------------------------------------------------------------------------
/** Compares two paths lexicographically.
* The comparison is based on the Unicode value
* of each character in the strings that make up path parts.
* The result is zero if two paths are equal:
* exactly when the equals(other) would return true.
*
* @return The value 0 if the argument string is equal to this string;
* @return a value less than 0 if this string is lexicographically less than the string argument;
* @return and a value greater than 0 if this string is lexicographically greater than the string argument.
*/
virtual int compareTo(const Path& other) const;
/** Tests if this path starts with the given path.
* @param other
* @return True, if this path object starts with the given
*/
bool startsWith(const Path& other) const;
/** Tests if this path string representation starts with the string given.
* @param str A string to test
* @return True, if this path object starts with the given string
*/
bool startsWith(const String& str) const {
// FIXME: Wasteful allocation of string representation
return toString().startsWith(str);
}
/** Tests if this path ends with the given path.
* @param other
* @return True, if this path object ends with the given
*/
bool endsWith(const Path& other) const;
/** Tests if this path ends with the given string.
* @param other
* @return True, if this path object ends with the given
*/
bool endsWith(const String& other) const {
// FIXME: Wasteful allocation of string representation
return toString().endsWith(other);
}
/** Determine if the path contains a given subpath.
*
* @param path The subpath to search for.
* @return <b>true</b> if the path contains the subpath, <b>false</b> otherwise.
*/
bool contains(const Path& path) const;
/** Determine if the path string representation contains a given substring.
*
* @param str The substring to search for.
* @return <b>true</b> if the path contains the substring, <b>false</b> otherwise.
*/
bool contains(const String& str) const {
// FIXME: Wasteful allocation of string representation
return toString().contains(str);
}
/** Returns a path that is this path with redundant name elements eliminated.
* @return path that is this path with redundant name elements eliminated.
*/
Path normalize() const;
// ---- decomposition ----
/** Get parent path or null path if this is the root
* @return Parent of this path or null
*/
Path getParent() const;
/**
* Returns the name of the object this path leads to
* @return The last element of the name sequence
*/
const String& getBasename() const;
/** Get number of components this path includes
* @brief getComponentsCount
* @return Number of path elements in this path
*/
size_type getComponentsCount() const noexcept;
/** Get number of components this path includes
* @brief getComponentsCount
* @return Number of path elements in this path
*/
const String& getComponent(size_type index) const;
const_iterator begin() const {
return _components.begin();
}
const_iterator end() const {
return _components.end();
}
/**
* Returns first component of this path
* @return first component of this path
*
* TODO: Should be Option<String> as components collection can be empty
*/
const String& first() const;
/**
* Returns last component of this path
* @return last component of this path
*
* TODO: Should be Option<String> as components collection can be empty
*/
const String& last() const;
/** Returns sub path of this path
* Splice of this path object
* @return Sub path of this path
*/
Path subpath(size_type beginIndex, size_type endIndex) const;
/**
* Concatenate this path with a give one
*/
Path join(const Path& rhs) const;
/**
* Append a component to this path
* @return A new path with appended component
*/
Path join(const String& rhs) const;
/** Tests this path for equality with the given object.
* @param rhv A path to compare this one to.
* @return True if this path is equal to the give
*/
bool equals(const Path& rhv) const noexcept override;
/** @see Iterable::forEach */
const Path& forEach(const std::function<void(const String&)> &f) const override;
/** Get string representation of the path object using give delimiter */
String toString(const String& delim) const;
/** @see IFormattable::toString() */
String toString() const override {
return toString(Delimiter);
}
private:
Array<String> _components;
};
/** Convenience joint operator */
inline Path operator / (const Path& lhs, const Path& rhs) {
return Path::join(lhs, rhs);
}
/** Convenience joint operator */
inline Path operator / (const Path& lhs, const String& rhs) {
return Path::join(lhs, rhs);
}
inline void swap(Path& lhs, Path& rhs) noexcept {
lhs.swap(rhs);
}
} // namespace Solace
#endif // SOLACE_PATH_HPP
| [
"abbyssoul@gmail.com"
] | abbyssoul@gmail.com |
bca42ff1ac8ab0ccae9aa7389e60e96302f3878a | 19f4f96232b00534892028e351691426a2e47968 | /A_k_rounding.cpp | 74c8d2fb47679245c9a10a7d0d4e25c1d98bf62b | [] | no_license | dhruvsahni89/codeforcesProblems | a6775040370a4439cf4a4c065f160055e5f89d09 | a339540cdbb82341a9eea0ede3b323cef5ba37ae | refs/heads/master | 2023-03-31T20:00:57.945691 | 2021-04-01T13:24:25 | 2021-04-01T13:24:25 | 353,707,406 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 426 | cpp | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i,n) for(int i=0;i<n;i++)
#define endl ("\n")
#define pb push_back
#define mp make_pair
#define pl pair<ll, ll>
#define vl vector<ll>
#define fastIO ios_base::sync_with_stdio(false);cin.tie(NULL);
#define N 100005
#define M 1000000007
int main()
{
fastIO
ll n,k;
cin>>n>>k;
ll y=1;
f(i,k)y=y*10;
ll x=__gcd(n,y);
cout<<(n*y)/x<<endl;
} | [
"dhruvsahni89@gmail.com"
] | dhruvsahni89@gmail.com |
5a59bffff4be1f955119ea7cd85136a47ec9f6c8 | c7fda71ef70a7ffcc59ba648e164f5b7666d3fc8 | /packages/eigen-eigen-323c052e1731/test/half_float.cpp | b37b81903a35f754f46b08832713b13f9c2eeb6e | [
"BSD-3-Clause",
"LGPL-2.0-or-later",
"LGPL-2.1-only",
"MPL-2.0",
"LGPL-2.1-or-later",
"GPL-3.0-only",
"Minpack",
"Apache-2.0"
] | permissive | ai-techsystems/deepC | 6c7df32ba61f2e85fc1eab5af4ef4f5c1368cf71 | 064a7cc04f96e20013ad7ae26a6abd6ef16ab77c | refs/heads/master | 2023-08-04T06:08:20.817613 | 2022-10-29T15:12:26 | 2022-10-29T15:12:26 | 193,276,319 | 343 | 69 | Apache-2.0 | 2021-08-19T19:39:50 | 2019-06-22T20:23:12 | C++ | UTF-8 | C++ | false | false | 10,819 | cpp | // This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <sstream>
#include "main.h"
#include <Eigen/src/Core/arch/CUDA/Half.h>
#ifdef EIGEN_HAS_CUDA_FP16
#error "EIGEN_HAS_CUDA_FP16 should not be defined in this CPU unit test"
#endif
// Make sure it's possible to forward declare Eigen::half
namespace Eigen {
struct half;
}
using Eigen::half;
void test_conversion()
{
using Eigen::half_impl::__half_raw;
// Conversion from float.
VERIFY_IS_EQUAL(half(1.0f).x, 0x3c00);
VERIFY_IS_EQUAL(half(0.5f).x, 0x3800);
VERIFY_IS_EQUAL(half(0.33333f).x, 0x3555);
VERIFY_IS_EQUAL(half(0.0f).x, 0x0000);
VERIFY_IS_EQUAL(half(-0.0f).x, 0x8000);
VERIFY_IS_EQUAL(half(65504.0f).x, 0x7bff);
VERIFY_IS_EQUAL(half(65536.0f).x, 0x7c00); // Becomes infinity.
// Denormals.
VERIFY_IS_EQUAL(half(-5.96046e-08f).x, 0x8001);
VERIFY_IS_EQUAL(half(5.96046e-08f).x, 0x0001);
VERIFY_IS_EQUAL(half(1.19209e-07f).x, 0x0002);
// Verify round-to-nearest-even behavior.
float val1 = float(half(__half_raw(0x3c00)));
float val2 = float(half(__half_raw(0x3c01)));
float val3 = float(half(__half_raw(0x3c02)));
VERIFY_IS_EQUAL(half(0.5f * (val1 + val2)).x, 0x3c00);
VERIFY_IS_EQUAL(half(0.5f * (val2 + val3)).x, 0x3c02);
// Conversion from int.
VERIFY_IS_EQUAL(half(-1).x, 0xbc00);
VERIFY_IS_EQUAL(half(0).x, 0x0000);
VERIFY_IS_EQUAL(half(1).x, 0x3c00);
VERIFY_IS_EQUAL(half(2).x, 0x4000);
VERIFY_IS_EQUAL(half(3).x, 0x4200);
// Conversion from bool.
VERIFY_IS_EQUAL(half(false).x, 0x0000);
VERIFY_IS_EQUAL(half(true).x, 0x3c00);
// Conversion to float.
VERIFY_IS_EQUAL(float(half(__half_raw(0x0000))), 0.0f);
VERIFY_IS_EQUAL(float(half(__half_raw(0x3c00))), 1.0f);
// Denormals.
VERIFY_IS_APPROX(float(half(__half_raw(0x8001))), -5.96046e-08f);
VERIFY_IS_APPROX(float(half(__half_raw(0x0001))), 5.96046e-08f);
VERIFY_IS_APPROX(float(half(__half_raw(0x0002))), 1.19209e-07f);
// NaNs and infinities.
VERIFY(!(numext::isinf)(float(half(65504.0f)))); // Largest finite number.
VERIFY(!(numext::isnan)(float(half(0.0f))));
VERIFY((numext::isinf)(float(half(__half_raw(0xfc00)))));
VERIFY((numext::isnan)(float(half(__half_raw(0xfc01)))));
VERIFY((numext::isinf)(float(half(__half_raw(0x7c00)))));
VERIFY((numext::isnan)(float(half(__half_raw(0x7c01)))));
#if !EIGEN_COMP_MSVC
// Visual Studio errors out on divisions by 0
VERIFY((numext::isnan)(float(half(0.0 / 0.0))));
VERIFY((numext::isinf)(float(half(1.0 / 0.0))));
VERIFY((numext::isinf)(float(half(-1.0 / 0.0))));
#endif
// Exactly same checks as above, just directly on the half representation.
VERIFY(!(numext::isinf)(half(__half_raw(0x7bff))));
VERIFY(!(numext::isnan)(half(__half_raw(0x0000))));
VERIFY((numext::isinf)(half(__half_raw(0xfc00))));
VERIFY((numext::isnan)(half(__half_raw(0xfc01))));
VERIFY((numext::isinf)(half(__half_raw(0x7c00))));
VERIFY((numext::isnan)(half(__half_raw(0x7c01))));
#if !EIGEN_COMP_MSVC
// Visual Studio errors out on divisions by 0
VERIFY((numext::isnan)(half(0.0 / 0.0)));
VERIFY((numext::isinf)(half(1.0 / 0.0)));
VERIFY((numext::isinf)(half(-1.0 / 0.0)));
#endif
}
void test_numtraits()
{
std::cout << "epsilon = " << NumTraits<half>::epsilon() << " (0x" << std::hex << NumTraits<half>::epsilon().x << ")" << std::endl;
std::cout << "highest = " << NumTraits<half>::highest() << " (0x" << std::hex << NumTraits<half>::highest().x << ")" << std::endl;
std::cout << "lowest = " << NumTraits<half>::lowest() << " (0x" << std::hex << NumTraits<half>::lowest().x << ")" << std::endl;
std::cout << "min = " << (std::numeric_limits<half>::min)() << " (0x" << std::hex << half((std::numeric_limits<half>::min)()).x << ")" << std::endl;
std::cout << "denorm min = " << (std::numeric_limits<half>::denorm_min)() << " (0x" << std::hex << half((std::numeric_limits<half>::denorm_min)()).x << ")" << std::endl;
std::cout << "infinity = " << NumTraits<half>::infinity() << " (0x" << std::hex << NumTraits<half>::infinity().x << ")" << std::endl;
std::cout << "quiet nan = " << NumTraits<half>::quiet_NaN() << " (0x" << std::hex << NumTraits<half>::quiet_NaN().x << ")" << std::endl;
std::cout << "signaling nan = " << std::numeric_limits<half>::signaling_NaN() << " (0x" << std::hex << std::numeric_limits<half>::signaling_NaN().x << ")" << std::endl;
VERIFY(NumTraits<half>::IsSigned);
VERIFY_IS_EQUAL( std::numeric_limits<half>::infinity().x, half(std::numeric_limits<float>::infinity()).x );
VERIFY_IS_EQUAL( std::numeric_limits<half>::quiet_NaN().x, half(std::numeric_limits<float>::quiet_NaN()).x );
VERIFY_IS_EQUAL( std::numeric_limits<half>::signaling_NaN().x, half(std::numeric_limits<float>::signaling_NaN()).x );
VERIFY( (std::numeric_limits<half>::min)() > half(0.f) );
VERIFY( (std::numeric_limits<half>::denorm_min)() > half(0.f) );
VERIFY( (std::numeric_limits<half>::min)()/half(2) > half(0.f) );
VERIFY_IS_EQUAL( (std::numeric_limits<half>::denorm_min)()/half(2), half(0.f) );
}
void test_arithmetic()
{
VERIFY_IS_EQUAL(float(half(2) + half(2)), 4);
VERIFY_IS_EQUAL(float(half(2) + half(-2)), 0);
VERIFY_IS_APPROX(float(half(0.33333f) + half(0.66667f)), 1.0f);
VERIFY_IS_EQUAL(float(half(2.0f) * half(-5.5f)), -11.0f);
VERIFY_IS_APPROX(float(half(1.0f) / half(3.0f)), 0.33333f);
VERIFY_IS_EQUAL(float(-half(4096.0f)), -4096.0f);
VERIFY_IS_EQUAL(float(-half(-4096.0f)), 4096.0f);
}
void test_comparison()
{
VERIFY(half(1.0f) > half(0.5f));
VERIFY(half(0.5f) < half(1.0f));
VERIFY(!(half(1.0f) < half(0.5f)));
VERIFY(!(half(0.5f) > half(1.0f)));
VERIFY(!(half(4.0f) > half(4.0f)));
VERIFY(!(half(4.0f) < half(4.0f)));
VERIFY(!(half(0.0f) < half(-0.0f)));
VERIFY(!(half(-0.0f) < half(0.0f)));
VERIFY(!(half(0.0f) > half(-0.0f)));
VERIFY(!(half(-0.0f) > half(0.0f)));
VERIFY(half(0.2f) > half(-1.0f));
VERIFY(half(-1.0f) < half(0.2f));
VERIFY(half(-16.0f) < half(-15.0f));
VERIFY(half(1.0f) == half(1.0f));
VERIFY(half(1.0f) != half(2.0f));
// Comparisons with NaNs and infinities.
#if !EIGEN_COMP_MSVC
// Visual Studio errors out on divisions by 0
VERIFY(!(half(0.0 / 0.0) == half(0.0 / 0.0)));
VERIFY(half(0.0 / 0.0) != half(0.0 / 0.0));
VERIFY(!(half(1.0) == half(0.0 / 0.0)));
VERIFY(!(half(1.0) < half(0.0 / 0.0)));
VERIFY(!(half(1.0) > half(0.0 / 0.0)));
VERIFY(half(1.0) != half(0.0 / 0.0));
VERIFY(half(1.0) < half(1.0 / 0.0));
VERIFY(half(1.0) > half(-1.0 / 0.0));
#endif
}
void test_basic_functions()
{
VERIFY_IS_EQUAL(float(numext::abs(half(3.5f))), 3.5f);
VERIFY_IS_EQUAL(float(abs(half(3.5f))), 3.5f);
VERIFY_IS_EQUAL(float(numext::abs(half(-3.5f))), 3.5f);
VERIFY_IS_EQUAL(float(abs(half(-3.5f))), 3.5f);
VERIFY_IS_EQUAL(float(numext::floor(half(3.5f))), 3.0f);
VERIFY_IS_EQUAL(float(floor(half(3.5f))), 3.0f);
VERIFY_IS_EQUAL(float(numext::floor(half(-3.5f))), -4.0f);
VERIFY_IS_EQUAL(float(floor(half(-3.5f))), -4.0f);
VERIFY_IS_EQUAL(float(numext::ceil(half(3.5f))), 4.0f);
VERIFY_IS_EQUAL(float(ceil(half(3.5f))), 4.0f);
VERIFY_IS_EQUAL(float(numext::ceil(half(-3.5f))), -3.0f);
VERIFY_IS_EQUAL(float(ceil(half(-3.5f))), -3.0f);
VERIFY_IS_APPROX(float(numext::sqrt(half(0.0f))), 0.0f);
VERIFY_IS_APPROX(float(sqrt(half(0.0f))), 0.0f);
VERIFY_IS_APPROX(float(numext::sqrt(half(4.0f))), 2.0f);
VERIFY_IS_APPROX(float(sqrt(half(4.0f))), 2.0f);
VERIFY_IS_APPROX(float(numext::pow(half(0.0f), half(1.0f))), 0.0f);
VERIFY_IS_APPROX(float(pow(half(0.0f), half(1.0f))), 0.0f);
VERIFY_IS_APPROX(float(numext::pow(half(2.0f), half(2.0f))), 4.0f);
VERIFY_IS_APPROX(float(pow(half(2.0f), half(2.0f))), 4.0f);
VERIFY_IS_EQUAL(float(numext::exp(half(0.0f))), 1.0f);
VERIFY_IS_EQUAL(float(exp(half(0.0f))), 1.0f);
VERIFY_IS_APPROX(float(numext::exp(half(EIGEN_PI))), 20.f + float(EIGEN_PI));
VERIFY_IS_APPROX(float(exp(half(EIGEN_PI))), 20.f + float(EIGEN_PI));
VERIFY_IS_EQUAL(float(numext::log(half(1.0f))), 0.0f);
VERIFY_IS_EQUAL(float(log(half(1.0f))), 0.0f);
VERIFY_IS_APPROX(float(numext::log(half(10.0f))), 2.30273f);
VERIFY_IS_APPROX(float(log(half(10.0f))), 2.30273f);
VERIFY_IS_EQUAL(float(numext::log1p(half(0.0f))), 0.0f);
VERIFY_IS_EQUAL(float(log1p(half(0.0f))), 0.0f);
VERIFY_IS_APPROX(float(numext::log1p(half(10.0f))), 2.3978953f);
VERIFY_IS_APPROX(float(log1p(half(10.0f))), 2.3978953f);
}
void test_trigonometric_functions()
{
VERIFY_IS_APPROX(numext::cos(half(0.0f)), half(cosf(0.0f)));
VERIFY_IS_APPROX(cos(half(0.0f)), half(cosf(0.0f)));
VERIFY_IS_APPROX(numext::cos(half(EIGEN_PI)), half(cosf(EIGEN_PI)));
//VERIFY_IS_APPROX(numext::cos(half(EIGEN_PI/2)), half(cosf(EIGEN_PI/2)));
//VERIFY_IS_APPROX(numext::cos(half(3*EIGEN_PI/2)), half(cosf(3*EIGEN_PI/2)));
VERIFY_IS_APPROX(numext::cos(half(3.5f)), half(cosf(3.5f)));
VERIFY_IS_APPROX(numext::sin(half(0.0f)), half(sinf(0.0f)));
VERIFY_IS_APPROX(sin(half(0.0f)), half(sinf(0.0f)));
// VERIFY_IS_APPROX(numext::sin(half(EIGEN_PI)), half(sinf(EIGEN_PI)));
VERIFY_IS_APPROX(numext::sin(half(EIGEN_PI/2)), half(sinf(EIGEN_PI/2)));
VERIFY_IS_APPROX(numext::sin(half(3*EIGEN_PI/2)), half(sinf(3*EIGEN_PI/2)));
VERIFY_IS_APPROX(numext::sin(half(3.5f)), half(sinf(3.5f)));
VERIFY_IS_APPROX(numext::tan(half(0.0f)), half(tanf(0.0f)));
VERIFY_IS_APPROX(tan(half(0.0f)), half(tanf(0.0f)));
// VERIFY_IS_APPROX(numext::tan(half(EIGEN_PI)), half(tanf(EIGEN_PI)));
// VERIFY_IS_APPROX(numext::tan(half(EIGEN_PI/2)), half(tanf(EIGEN_PI/2)));
//VERIFY_IS_APPROX(numext::tan(half(3*EIGEN_PI/2)), half(tanf(3*EIGEN_PI/2)));
VERIFY_IS_APPROX(numext::tan(half(3.5f)), half(tanf(3.5f)));
}
void test_array()
{
typedef Array<half,1,Dynamic> ArrayXh;
Index size = internal::random<Index>(1,10);
Index i = internal::random<Index>(0,size-1);
ArrayXh a1 = ArrayXh::Random(size), a2 = ArrayXh::Random(size);
VERIFY_IS_APPROX( a1+a1, half(2)*a1 );
VERIFY( (a1.abs() >= half(0)).all() );
VERIFY_IS_APPROX( (a1*a1).sqrt(), a1.abs() );
VERIFY( ((a1.min)(a2) <= (a1.max)(a2)).all() );
a1(i) = half(-10.);
VERIFY_IS_EQUAL( a1.minCoeff(), half(-10.) );
a1(i) = half(10.);
VERIFY_IS_EQUAL( a1.maxCoeff(), half(10.) );
std::stringstream ss;
ss << a1;
}
void test_half_float()
{
CALL_SUBTEST(test_conversion());
CALL_SUBTEST(test_numtraits());
CALL_SUBTEST(test_arithmetic());
CALL_SUBTEST(test_comparison());
CALL_SUBTEST(test_basic_functions());
CALL_SUBTEST(test_trigonometric_functions());
CALL_SUBTEST(test_array());
}
| [
"srohit_pda@aitsdnnc1.us-central1-a.c.dnncompiler.internal"
] | srohit_pda@aitsdnnc1.us-central1-a.c.dnncompiler.internal |
eb4f15f696b9f24ad18e11f3d5f5dff502f4cdaa | e85338f6d8666eb476698de5025c742b9b838a50 | /ojs/cf/936A.cpp | ccdbe6e73bf448f6343682a4441f269add0fb7c3 | [] | no_license | yancouto/competitive-programming | 8104bb3c45e0b385c2abb4cfcac14c35cce0619e | ac849e3aa858eea56b0aa6b7eb93e9a9e70f9475 | refs/heads/master | 2022-10-19T11:29:46.932829 | 2022-10-07T00:16:43 | 2022-10-07T00:16:43 | 66,641,933 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,090 | cpp | #include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
const ll modn = 1000000007;
inline ll mod(ll x) { return x % modn; }
#ifdef ONLINE_JUDGE
# define debug(args...) ((void) 0)
#else
# define debug(args...) fprintf(stderr, args)
#endif
int n;
typedef long double ld;
int main() {
ll k,d , t;
cin >> k >> d >> t;
if(d < k)
d = ll((k + d - 1) / d) * d;
cout << "k " << k << " d " << d << endl;
ll a = k;
ll b = d - k;
cout << "a " << a << " b " << b << endl;
ll full = (2ll * t) / (2ll * a + b);
ll g = (2ll * t) % (2ll * a + b);
ld tm = ld(full) * (a + b);
printf("base %.5f\n", double(tm));
if(g) {
cout << "g " << g << "/" << 2 * a + b<< endl;
if(ld(a) / ld(t) >= ld(g) / ld(2 * a + b)) {
printf("Case A\n");
tm += ld(ld(g) / ld(2 * a + b)) * ld(t);
} else {
printf("Case B\n");
cout << tm << endl;
tm += a;
cout << tm << endl;
tm += ((ld(g) / ld(2 * a + b)) - ld(a) / ld(t)) * 2.0l * ld(t);
cout << tm << endl;
}
}
cout << tm << endl;
}
| [
"yancouto@gmail.com"
] | yancouto@gmail.com |
c3c105188abe44717b2a858b95919b2c550bd598 | 73ee941896043f9b3e2ab40028d24ddd202f695f | /external/chromium_org/chrome/browser/ui/startup/session_crashed_infobar_delegate_unittest.cc | 473928d924a3d8df7c1deba8b84e673c73917426 | [
"BSD-3-Clause"
] | permissive | CyFI-Lab-Public/RetroScope | d441ea28b33aceeb9888c330a54b033cd7d48b05 | 276b5b03d63f49235db74f2c501057abb9e79d89 | refs/heads/master | 2022-04-08T23:11:44.482107 | 2016-09-22T20:15:43 | 2016-09-22T20:15:43 | 58,890,600 | 5 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 3,592 | cc | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/startup/session_crashed_infobar_delegate.h"
#include "base/prefs/pref_registry_simple.h"
#include "base/prefs/testing_pref_service.h"
#include "base/run_loop.h"
#include "chrome/browser/infobars/infobar_service.h"
#include "chrome/browser/sessions/session_service_factory.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
#include "chrome/test/base/browser_with_test_window_test.h"
#include "chrome/test/base/scoped_testing_local_state.h"
#include "chrome/test/base/testing_browser_process.h"
class SessionCrashedInfoBarDelegateUnitTest : public BrowserWithTestWindowTest {
public:
virtual void SetUp() OVERRIDE {
pref_service.registry()
->RegisterBooleanPref(prefs::kAllowFileSelectionDialogs, true);
pref_service.registry()->RegisterBooleanPref(prefs::kWasRestarted, false);
static_cast<TestingBrowserProcess*>(g_browser_process)
->SetLocalState(&pref_service);
// This needs to be called after the local state is set, because it will
// create a browser which will try to read from the local state.
BrowserWithTestWindowTest::SetUp();
}
virtual void TearDown() OVERRIDE {
static_cast<TestingBrowserProcess*>(g_browser_process)->SetLocalState(NULL);
BrowserWithTestWindowTest::TearDown();
}
private:
TestingPrefServiceSimple pref_service;
};
TEST_F(SessionCrashedInfoBarDelegateUnitTest, DetachingTabWithCrashedInfoBar) {
SessionServiceFactory::SetForTestProfile(
browser()->profile(),
static_cast<SessionService*>(
SessionServiceFactory::GetInstance()->BuildServiceInstanceFor(
browser()->profile())));
// Create a browser which we can close during the test.
Browser::CreateParams params(browser()->profile(),
browser()->host_desktop_type());
scoped_ptr<Browser> first_browser(
chrome::CreateBrowserWithTestWindowForParams(¶ms));
AddTab(first_browser.get(), GURL(chrome::kChromeUINewTabURL));
// Attach the crashed infobar to it.
SessionCrashedInfoBarDelegate::Create(first_browser.get());
TabStripModel* tab_strip = first_browser->tab_strip_model();
ASSERT_EQ(1, tab_strip->count());
content::WebContents* web_contents = tab_strip->GetWebContentsAt(0);
InfoBarService* infobar_service =
InfoBarService::FromWebContents(web_contents);
EXPECT_EQ(1U, infobar_service->infobar_count());
scoped_ptr<ConfirmInfoBarDelegate> infobar(InfoBarService::FromWebContents(
web_contents)->infobar_at(0)->AsConfirmInfoBarDelegate());
ASSERT_TRUE(infobar);
// Open another browser.
scoped_ptr<Browser> opened_browser(
chrome::CreateBrowserWithTestWindowForParams(¶ms));
// Move the tab which is destroying the crash info bar to the new browser.
tab_strip->DetachWebContentsAt(0);
tab_strip = opened_browser->tab_strip_model();
tab_strip->AppendWebContents(web_contents, true);
// Close the original browser.
first_browser->window()->Close();
first_browser.reset();
ASSERT_EQ(1, tab_strip->count());
web_contents = tab_strip->GetWebContentsAt(0);
infobar_service = InfoBarService::FromWebContents(web_contents);
EXPECT_EQ(1U, infobar_service->infobar_count());
// This used to crash.
infobar->Accept();
// Ramp down the test.
tab_strip->CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
}
| [
"ProjectRetroScope@gmail.com"
] | ProjectRetroScope@gmail.com |
b6e76b976c0b5bc9b736db1e9bc870a482884742 | 2771893a93bdf0b9c2d06d78c9099f7c92e92709 | /c++/047-PermutationsII.cpp | 67170757e61fdc525538b6475383c1a3b16c2e4b | [] | no_license | tangzecn/leetcode | 2144ba31727ca6f2c81c537ab41ef4ba400564b6 | 1a5ebb9c036bea4910002a6dfa260804193134b7 | refs/heads/master | 2021-06-08T13:03:33.641424 | 2017-06-07T22:23:00 | 2017-06-07T22:23:00 | 28,834,674 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,276 | cpp | #include<iostream>
#include<vector>
using namespace std;
class Solution {
public:
vector<vector<int> > permuteUnique(vector<int> &num) {
vector<vector<int> > ans;
if (num.size() > 0) {
std::sort(num.begin(), num.end());
vector<int> solution(num.size());
vector<bool> mark(num.size());
for (int i=0; i<num.size(); i++) {
solution[i] = 0;
mark[i] = false;
}
permuteUnique(0, -1, num, mark, solution, ans);
}
return ans;
}
void permuteUnique(const int level, const int lastPos, const vector<int> &num,
vector<bool> &mark, vector<int> &solution, vector<vector<int> > &ans) {
if (level >= num.size()) {
ans.push_back(solution);
return;
}
int minPos = (level > 0 && num[level] == num[level - 1]) ? lastPos + 1 : 0;
for (int i=minPos; i<num.size(); i++) {
if (!mark[i]) {
mark[i] = true;
solution[i] = num[level];
permuteUnique(level + 1, i, num, mark, solution, ans);
solution[i] = 0;
mark[i] = false;
}
}
}
};
int main() {
return 0;
} | [
"tangzecn@gmail.com"
] | tangzecn@gmail.com |
9f8c948592f4126db1615dc7f25eee07381f2a48 | 99e85aedc7899806a9a98a8f1f1a9c131e67b0da | /124/LAB/WK13-Lab12/binarytree.cpp | 53ccc6169a3ff1b6773ea428719a66c3a74dfdd4 | [] | no_license | LexiMuMu/cpp | 41fb95a8a17b50a758ebe9fc51d965c26ad2b83e | 84d36e8b4606c4210f4a6399180852d8d2f5eb03 | refs/heads/master | 2021-01-11T05:40:40.819541 | 2016-10-21T13:36:17 | 2016-10-21T13:36:17 | 71,566,106 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,635 | cpp | /************************************************************
BinaryTree class implements a binary search tree.
It expects a datatype T
and functions
void copy(T &A, const T& B);
int cmp(const T& left, const T& right);
void print(const T& t);
to be defined through datatype.h
Consider how the implementation might change if
it expected a class T
with appropriate constructors,
comparison operators and
stream insertion operator
************************************************************/
#include <iostream>
#include "binarytree.h"
BinaryTree::BinaryTree()
{
root = NULL;
}
BinaryTree::~BinaryTree()
{
postorderDelete(root);
root = NULL;
}
void BinaryTree::insert(const T& in)
{
if (root==NULL)
root = createNode(in);
else
insertNode(root, in);
}
bool BinaryTree::search(T & out, const T& key) const
{
nptr target = findNode(root, key);
if (target==NULL)
return false;
else
{
copy(out, target->data);
return true;
}
}
void BinaryTree::printAll() const
{
inorderPrint(root);
}
void BinaryTree::preorderPrintAll() const
{
preorderPrint(root);
}
void BinaryTree::applyToAll(void (*func)(const T&))
{
inorderApply(root, func);
}
bool BinaryTree::remove(T& out, const T&key)
{
return removeRe(root, out, key);
}
void BinaryTree::clear()
{
postorderDelete(root);
root = NULL;
}
void BinaryTree::postorderDelete(nptr cur)
{
if (cur!=NULL) {
postorderDelete(cur->left);
postorderDelete(cur->right);
delete cur;
}
}
BinaryTree::nptr BinaryTree::createNode(const T &data) const
{
nptr tmp = new node;
copy(tmp->data, data);
tmp->left = NULL;
tmp->right = NULL;
tmp->parent = NULL;
return tmp;
}
void BinaryTree::insertNode(nptr &cur, const T& data)
{
if (cmp(data, cur->data) > 0) {
if (cur->right==NULL) {
cur->right = createNode(data);
(cur->right)->parent = cur;
} else
insertNode(cur->right, data);
} else {
if (cur->left==NULL) {
cur->left = createNode(data);
(cur->left)->parent = cur;
} else
insertNode(cur->left, data);
}
}
BinaryTree::nptr BinaryTree::findNode(nptr cur, const T& key) const
{
if (cur==NULL)
return NULL;
else if (cmp(key,cur->data)==0)
{
return cur;
} else if (cmp(key, cur->data) > 0)
{
return findNode(cur->right, key);
} else
return findNode(cur->left, key);
}
void BinaryTree::inorderPrint(nptr cur) const
{
if(cur != NULL) {
inorderPrint(cur->left);
print(cur->data);
inorderPrint(cur->right);
}
}
void BinaryTree::preorderPrint(nptr cur) const
{
if(cur != NULL) {
print(cur->data);
inorderPrint(cur->left);
inorderPrint(cur->right);
}
}
void BinaryTree::inorderApply(nptr cur, void (*func)(const T&)) const
{
if(cur != NULL) {
inorderApply(cur->left, func);
func(cur->data);
inorderApply(cur->right, func);
}
}
bool BinaryTree::removeRe(nptr &cur, T& out, const T& key)
{
if (cur==NULL)
return false;
if (cmp(key, cur->data)>0)
return removeRe(cur->right, out, key);
else if (cmp(key, cur->data)<0)
return removeRe(cur->left, out, key);
else // found!
return removeNode(cur, out);
}
bool BinaryTree::removeNode(nptr &target, T& out)
{
if (target==NULL)
return false;
if (target->left!=NULL&&target->right!=NULL) {
nptr largest=findLargest(target->left);
largest->right = target->right;
target->right->parent = largest;
}
copy(out, target->data);
nptr tmp = target;
if (target->left ==NULL)
target = target->right;
else
target = target->left;
if (target!=NULL)
target->parent = tmp->parent;
delete tmp;
return true;
}
BinaryTree::nptr BinaryTree::findLargest(nptr cur) const
{
while (cur->right !=NULL)
cur = cur->right;
return cur;
}
| [
"mulan@Lexi.local"
] | mulan@Lexi.local |
326bd8445ecbdcc33aee2801d492a8d8964a5424 | 246ce285c303f8be56547b093ad1eb81f51bb3a4 | /Prática TP - Exercícios TP2/Exercícios TP2/Felipe-Magalhaes-Exercicio02/exe2.cpp | 906778ab20b3661577a1b74a190a806a4540b9a0 | [] | no_license | fonte-nele/BCC202-Estrutura-de-Dados-I | 7a9eb3b4b7375c91558951ee7b1a6f92149963c9 | 26fc3b865798703fe7002efd1d0f28f68d07920a | refs/heads/master | 2020-06-08T16:13:10.921443 | 2019-06-22T17:21:27 | 2019-06-22T17:21:27 | 193,260,618 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,692 | cpp | #include"exe2.h"
void ordenacao_mexida(string lista)
{
int cont=1,i=0,j=1;
//Contagem da quantidade de palavras e numeros!!!
while(lista[i]!='.')
{
if(lista[i]==',')
{
if(lista[j]==' ')
{
cont++;
}
}
i++;
j++;
}
string *v,*v2,*v3;
int v4[cont],tam2=0,tam3=0;
v= new string[cont];
Extrair_dados(v,lista);
for(i=0;i<cont;i++)
{
if(isalpha(v[i][0]))
{
//Verificar tamanho do vetor de numeros e palavras.
tam2++;
//Flag para guardar as posicoes do vetor, 1-palavras 2-numeros.
v4[i]=1;
}
else
{
tam3++;
v4[i]=2;
}
}
v2= new string[tam2];
v3= new string[tam3];
Separar_vetores(v,v2,v3,cont);
Bolha(v2,tam2);
Bolha(v3,tam3);
Intercalar(v,v2,v3,v4,cont);
Imprimir(v,cont);
delete []v2;
delete []v3;
delete []v;
}
void Extrair_dados(string *v,string lista)
{
int i,j,k,tam,cont=0,inicio=0;
tam=lista.size();
//Extraindo palavras e numeros colocando em um vetor.
for(i=0,j=1,k=0;i<tam;i++,j++)
{
cont++;
if(lista[i]==',')
{
if(lista[j]==' ')
{
v[k++]=lista.substr(inicio,cont-1);
inicio=j+1;
cont=-1;
}
}
}
v[k]=lista.substr(inicio,cont-1);
}
void Separar_vetores(string *v,string *v2,string *v3,int cont)
{
//Separacao em dois vetores, palavras e numeros.
int i,j,k;
for(i=0,j=0,k=0;i<cont;i++)
{
if(isalpha(v[i][0]))
{
v2[j++]=v[i];
}
else
{
v3[k++]=v[i];
}
}
}
void Bolha(string *v,int n)
{
int i,j,tam1,tam2;
string aux;
for(i=0;i<n-1;i++)
{
for(j=1;j<n-i;j++)
{
if(isalpha(v[j][0]))
{
if(tolower(v[j][0])==tolower(v[j-1][0]))
{
if(tolower(v[j][1])<tolower(v[j-1][1]))
{
aux=v[j];
v[j]=v[j-1];
v[j-1]=aux;
}
}
if(tolower(v[j][0])<tolower(v[j-1][0]))
{
aux=v[j];
v[j]=v[j-1];
v[j-1]=aux;
}
}
else
{
tam1=v[j-1].size();
tam2=v[j].size();
if(ispunct(v[j-1][0]) || ispunct(v[j][0]))
{
if(v[j]<v[j-1])
{
aux=v[j];
v[j]=v[j-1];
v[j-1]=aux;
}
}
else
{
if(tam1==tam2)
{
if(v[j]<v[j-1])
{
aux=v[j];
v[j]=v[j-1];
v[j-1]=aux;
}
}
else
{
if(tam1>tam2)
{
aux=v[j-1];
v[j-1]=v[j];
v[j]=aux;
}
}
}
}
}
}
}
void Intercalar(string *v,string *v2,string *v3,int *v4,int cont)
{
int i,j,k;
for(i=0,j=0,k=0;i<cont;i++)
{
if(v4[i]==1)
{
v[i]=v2[j++];
}
else
{
v[i]=v3[k++];
}
}
}
void Imprimir(string *v, int cont)
{
cout<<endl<<endl<<"A LISTA ORDENADA EH:"<<endl;
for(int i=0;i<cont;i++)
{
if(i!=cont-1)
{
cout<<v[i]<<", ";
}
else
{
cout<<v[i]<<".";
}
}
} | [
"felipephontinelly@hotmail.com"
] | felipephontinelly@hotmail.com |
8cbdcc9802bf880e628a5a8b5a2c6c291d863d5c | 2bf341adf99aa12769657e1f2041a103e3a88e05 | /TextureManager.h | f5fabbde01574eb65209d8ff84825ba3162288f7 | [] | no_license | rontgen/MySDLGame | 67949d9492411b64eaffa915b672a51d6d5738fa | 8e34d17bd983c625d281dc39f805b8fe5e56bd18 | refs/heads/main | 2023-06-14T20:18:07.038006 | 2021-07-10T10:12:23 | 2021-07-10T10:12:23 | 380,527,683 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 760 | h | /**
* Author:gwang
* Date: 2021-07-03
* Description: Texture Manager singleton Class Related
*/
#pragma once
#include <string>
#include <map>
#include <SDL.h>
using std::string;
using std::map;
class TextureManager
{
public:
bool load(string fileName, string id, SDL_Renderer* pRenderer);
void draw(string id, int x, int y, int w, int h,
SDL_Renderer* pRenderer, SDL_RendererFlip flip = SDL_FLIP_NONE);
void drawFrame(string id, int x, int y, int w, int h, int currentRow, int currentFrame,
SDL_Renderer* pRenderer, SDL_RendererFlip flip = SDL_FLIP_NONE);
static TextureManager* instance();
private:
TextureManager() = default;
private:
static TextureManager* s_instance;
map<string, SDL_Texture*> m_texMap;
};
| [
"minstrelgen@163.com"
] | minstrelgen@163.com |
ffdc6aa293bbf11d81df8428bd4933d43cd173ab | a69d5864881796a677b96973b61423141f4fe125 | /stdafx.cpp | 00748590e7eb1c7a3d1d8e25650a200ab765737b | [] | no_license | sxr412/potato_spot_recognition_system | ee7efe97bd432958c14b6de8390b90ab73cc5f03 | f8d6e9e94272ddac202d9e561fd27d1ee7347745 | refs/heads/master | 2020-03-26T03:28:03.267959 | 2018-08-12T12:10:00 | 2018-08-12T12:10:00 | 144,457,308 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 165 | cpp |
// stdafx.cpp : 只包括标准包含文件的源文件
// windowTest.pch 将作为预编译头
// stdafx.obj 将包含预编译类型信息
#include "stdafx.h"
| [
"31792286+sxr412@users.noreply.github.com"
] | 31792286+sxr412@users.noreply.github.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.