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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
3bf72a8caa0f12ecab67d38f0be16f12ef11e463 | 67be94dcfaff3d818037be4c655fef94362c1f49 | /Src/Modules/wxLua/modules/wxluasocket/src/wxldserv.cpp | 4dd186e071cd327c68ad6a4621ce5631d46aa45e | [
"MIT"
] | permissive | wyrover/luaplus51-all | b32453b7b69060b53d6e91f98a32b972783c4912 | 43936c1430f124be62ed4983f55df1e56068dfa7 | refs/heads/master | 2021-01-18T05:25:22.325866 | 2013-08-27T06:42:23 | 2013-08-27T06:42:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 35,527 | cpp | /////////////////////////////////////////////////////////////////////////////
// Name: wxldserv.cpp
// Purpose: Provide remote debugging support for wxLua.
// Author: J. Winwood, John Labenski, Ray Gilbert
// Created: May 2002.
// Copyright: (c) 2012 John Labenski, 2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "wx/thread.h"
#include "wxluasocket/include/wxldserv.h"
#include "wxluadebug/include/wxlstack.h"
#if !wxCHECK_VERSION(2, 6, 0)
#define wxMilliSleep wxUsleep
#endif // !wxCHECK_VERSION(2, 6, 0)
// ----------------------------------------------------------------------------
// wxLuaDebuggerEvent
// ----------------------------------------------------------------------------
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_CONNECTED)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_BREAK)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_PRINT)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_ERROR)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_EXIT)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_STACK_ENUM)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_STACK_ENTRY_ENUM)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_TABLE_ENUM)
DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_EVALUATE_EXPR)
//DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_STARTDEBUGGER)
//DEFINE_EVENT_TYPE(wxEVT_WXLUA_DEBUGGER_STOPDEBUGGER)
IMPLEMENT_DYNAMIC_CLASS(wxLuaDebuggerEvent, wxEvent)
wxLuaDebuggerEvent::wxLuaDebuggerEvent(const wxLuaDebuggerEvent& event)
:wxEvent(event),
m_line_number(event.m_line_number),
m_fileName(event.m_fileName),
m_strMessage(event.m_strMessage),
m_has_message(event.m_has_message),
m_lua_ref(event.m_lua_ref),
m_debugData(event.m_debugData),
m_enabled_flag(event.m_enabled_flag)
{
}
wxLuaDebuggerEvent::wxLuaDebuggerEvent(wxEventType eventType,
wxObject* eventObject,
int line_number,
const wxString &file, bool enabled_flag)
:wxEvent(0, eventType),
m_line_number(line_number),
m_fileName(file),
m_has_message(false),
m_lua_ref(-1),
m_debugData(wxNullLuaDebugData),
m_enabled_flag(enabled_flag)
{
SetEventObject(eventObject);
}
void wxLuaDebuggerEvent::SetMessage(const wxString& message)
{
m_strMessage = message;
m_has_message = true;
}
void wxLuaDebuggerEvent::SetDebugData(long nReference, const wxLuaDebugData& debugData)
{
m_lua_ref = nReference;
m_debugData = debugData;
}
// ----------------------------------------------------------------------------
// wxLuaDebuggerStackDialog
// ----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxLuaDebuggerStackDialog, wxLuaStackDialog)
wxLuaDebuggerStackDialog::wxLuaDebuggerStackDialog(wxLuaDebuggerBase* luaDebugger,
wxWindow* parent, wxWindowID id,
const wxString& title,
const wxPoint& pos, const wxSize& size)
: m_luaDebugger(luaDebugger)
{
wxCHECK_RET(m_luaDebugger != NULL, wxT("Invalid wxLuaDebuggerBase in wxLuaDebuggerStackDialog"));
// use delayed creation to allow our virtual functions to work
Create(wxNullLuaState, parent, id, title, pos, size);
}
wxLuaDebuggerStackDialog::~wxLuaDebuggerStackDialog()
{
if (m_luaDebugger != NULL)
m_luaDebugger->ClearDebugReferences();
}
void wxLuaDebuggerStackDialog::EnumerateStack()
{
wxCHECK_RET(m_luaDebugger, wxT("Invalid wxLuaDebuggerServer"));
wxBeginBusyCursor(); // ended in wxLuaDebuggerBase::OnDebugXXX
m_luaDebugger->EnumerateStack();
}
void wxLuaDebuggerStackDialog::EnumerateStackEntry(int nEntry)
{
wxCHECK_RET(m_luaDebugger, wxT("Invalid wxLuaDebuggerServer"));
wxBeginBusyCursor(); // ended in wxLuaDebuggerBase::OnDebugXXX
m_luaDebugger->EnumerateStackEntry(nEntry);
}
void wxLuaDebuggerStackDialog::EnumerateTable(int nRef, int nEntry, long lc_item)
{
wxCHECK_RET(m_luaDebugger, wxT("Invalid wxLuaDebuggerServer"));
wxBeginBusyCursor(); // ended in wxLuaDebuggerBase::OnDebugXXX
m_luaDebugger->EnumerateTable(nRef, nEntry, lc_item);
}
// ----------------------------------------------------------------------------
// wxLuaDebuggerProcess
// ----------------------------------------------------------------------------
void wxLuaDebuggerProcess::OnTerminate(int pid, int status)
{
// If this is being deleted from the destructor of wxLuaDebuggerBase
// it has already been NULLed so don't send event.
if (m_debugger && m_debugger->m_debuggeeProcess)
{
// we don't use the event handler, but this is good enough.
wxProcessEvent event(m_id, pid, status);
m_debugger->OnEndDebugeeProcess(event);
m_debugger->m_debuggeeProcess = NULL;
m_debugger->m_debuggeeProcessID = -1;
}
delete this;
}
// ----------------------------------------------------------------------------
// wxLuaDebuggerBase
// ----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxLuaDebuggerBase, wxEvtHandler)
wxString wxLuaDebuggerBase::sm_programName;
wxString wxLuaDebuggerBase::sm_networkName;
BEGIN_EVENT_TABLE(wxLuaDebuggerBase, wxEvtHandler)
EVT_WXLUA_DEBUGGER_STACK_ENUM( wxID_ANY, wxLuaDebuggerBase::OnDebugStackEnum)
EVT_WXLUA_DEBUGGER_STACK_ENTRY_ENUM( wxID_ANY, wxLuaDebuggerBase::OnDebugStackEntryEnum)
EVT_WXLUA_DEBUGGER_TABLE_ENUM( wxID_ANY, wxLuaDebuggerBase::OnDebugTableEnum)
//EVT_END_PROCESS(ID_WXLUASOCKET_DEBUGGEE_PROCESS, wxLuaDebuggerBase::OnEndDebugeeProcess)
END_EVENT_TABLE()
wxLuaDebuggerBase::wxLuaDebuggerBase(int port_number)
:wxEvtHandler(), m_port_number(port_number),
m_stackDialog(NULL),
m_debuggeeProcess(NULL), m_debuggeeProcessID(-1)
{
// Initialize the debuggee program name if not already set
if (sm_programName.IsEmpty())
sm_programName = wxTheApp->argv[0];
// Initialize the debuggee network name if not already set
if (sm_networkName.IsEmpty())
{
#ifdef __WXMSW__
sm_networkName = wxGetHostName();
#else
sm_networkName = wxT("localhost");
#endif // __WXMSW__
}
}
wxLuaDebuggerBase::~wxLuaDebuggerBase()
{
//wxPrintf(wxT("~wxLuaDebuggerBase the m_debuggeeProcess %p %d exists %d\n"), m_debuggeeProcess, m_debuggeeProcessID, wxProcess::Exists(m_debuggeeProcessID)); fflush(stdout);
// we don't delete the the process, we kill it and its OnTerminate deletes it
if ((m_debuggeeProcess != NULL) && (m_debuggeeProcessID > 0) &&
wxProcess::Exists(m_debuggeeProcessID))
{
m_debuggeeProcess->m_debugger = NULL;
m_debuggeeProcess = NULL;
wxProcess::Kill(m_debuggeeProcessID, wxSIGKILL, wxKILL_CHILDREN);
}
}
long wxLuaDebuggerBase::StartClient()
{
if (m_debuggeeProcess == NULL)
{
m_debuggeeProcess = new wxLuaDebuggerProcess(this, ID_WXLUASOCKET_DEBUGGEE_PROCESS);
wxString command = wxString::Format(wxT("%s -d%s:%u"),
GetProgramName().c_str(),
GetNetworkName().c_str(),
m_port_number);
m_debuggeeProcessID = wxExecute(command, wxEXEC_ASYNC|wxEXEC_MAKE_GROUP_LEADER, m_debuggeeProcess);
if (m_debuggeeProcessID < 1)
KillDebuggee();
}
return m_debuggeeProcessID;
}
bool wxLuaDebuggerBase::AddBreakPoint(const wxString &fileName, int lineNumber)
{
return CheckSocketConnected(true, wxT("Debugger AddBreakPoint")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_ADD_BREAKPOINT) &&
GetSocketBase()->WriteString(fileName) &&
GetSocketBase()->WriteInt32(lineNumber),
wxT("Debugger AddBreakPoint"));
}
bool wxLuaDebuggerBase::RemoveBreakPoint(const wxString &fileName, int lineNumber)
{
return CheckSocketConnected(true, wxT("Debugger RemoveBreakPoint")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_REMOVE_BREAKPOINT) &&
GetSocketBase()->WriteString(fileName) &&
GetSocketBase()->WriteInt32(lineNumber),
wxT("Debugger RemoveBreakPoint"));
}
bool wxLuaDebuggerBase::DisableBreakPoint(const wxString &fileName, int lineNumber)
{
return CheckSocketConnected(true, wxT("Debugger DisableBreakPoint")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_DISABLE_BREAKPOINT) &&
GetSocketBase()->WriteString(fileName) &&
GetSocketBase()->WriteInt32(lineNumber),
wxT("Debugger DisableBreakPoint"));
}
bool wxLuaDebuggerBase::EnableBreakPoint(const wxString &fileName, int lineNumber)
{
return CheckSocketConnected(true, wxT("Debugger EnableBreakPoint")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_ENABLE_BREAKPOINT) &&
GetSocketBase()->WriteString(fileName) &&
GetSocketBase()->WriteInt32(lineNumber),
wxT("Debugger EnableBreakPoint"));
}
bool wxLuaDebuggerBase::ClearAllBreakPoints()
{
return CheckSocketConnected(true, wxT("Debugger ClearAllBreakPoints")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_CLEAR_ALL_BREAKPOINTS),
wxT("Debugger ClearAllBreakPoints"));
}
bool wxLuaDebuggerBase::Run(const wxString &fileName, const wxString &buffer)
{
return CheckSocketConnected(true, wxT("Debugger Run")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_RUN_BUFFER) &&
GetSocketBase()->WriteString(fileName) &&
GetSocketBase()->WriteString(buffer),
wxT("Debugger Run"));
}
bool wxLuaDebuggerBase::Step()
{
return CheckSocketConnected(true, wxT("Debugger Step")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_DEBUG_STEP),
wxT("Debugger Step"));
}
bool wxLuaDebuggerBase::StepOver()
{
return CheckSocketConnected(true, wxT("Debugger StepOver")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_DEBUG_STEPOVER),
wxT("Debugger StepOver"));
}
bool wxLuaDebuggerBase::StepOut()
{
return CheckSocketConnected(true, wxT("Debugger StepOut")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_DEBUG_STEPOUT),
wxT("Debugger StepOut"));
}
bool wxLuaDebuggerBase::Continue()
{
return CheckSocketConnected(true, wxT("Debugger Continue")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_DEBUG_CONTINUE),
wxT("Debugger Continue"));
}
bool wxLuaDebuggerBase::Break()
{
return CheckSocketConnected(true, wxT("Debugger Break")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_DEBUG_BREAK),
wxT("Debugger Break"));
}
bool wxLuaDebuggerBase::Reset()
{
return CheckSocketConnected(true, wxT("Debugger Reset")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_RESET),
wxT("Debugger Reset"));
}
bool wxLuaDebuggerBase::EnumerateStack()
{
return CheckSocketConnected(true, wxT("Debugger EnumerateStack")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_ENUMERATE_STACK),
wxT("Debugger EnumerateStack"));
}
bool wxLuaDebuggerBase::EnumerateStackEntry(int stackEntry)
{
return CheckSocketConnected(true, wxT("Debugger EnumerateStackEntry")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_ENUMERATE_STACK_ENTRY) &&
GetSocketBase()->WriteInt32(stackEntry),
wxT("Debugger EnumerateStackEntry"));
}
bool wxLuaDebuggerBase::EnumerateTable(int tableRef, int nIndex, long nItemNode)
{
return CheckSocketConnected(true, wxT("Debugger EnumerateTable")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_ENUMERATE_TABLE_REF) &&
GetSocketBase()->WriteInt32(tableRef) &&
GetSocketBase()->WriteInt32(nIndex) &&
GetSocketBase()->WriteLong(nItemNode),
wxT("Debugger EnumerateTable"));
}
bool wxLuaDebuggerBase::ClearDebugReferences()
{
return CheckSocketConnected(true, wxT("Debugger ClearDebugReferences")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_CLEAR_DEBUG_REFERENCES),
wxT("Debugger ClearDebugReferences"));
}
bool wxLuaDebuggerBase::EvaluateExpr(int exprRef, const wxString &strExpression)
{
return CheckSocketConnected(true, wxT("Debugger EvaluateExpr")) && CheckSocketWrite(
GetSocketBase()->WriteCmd(wxLUASOCKET_DEBUGGER_CMD_EVALUATE_EXPR) &&
GetSocketBase()->WriteInt32(exprRef) &&
GetSocketBase()->WriteString(strExpression),
wxT("Debugger EvaluateExpr"));
}
//extern wxString wxLuaSocketCmdEventMsg(int val);
// This function shouldn't modify any internal variables without using a
// critical section since the wxLuaDebuggerCServer calls it from the thread.
int wxLuaDebuggerBase::HandleDebuggeeEvent(int event_type)
{
wxCHECK_MSG(GetSocketBase(), event_type, wxT("Invalid socket"));
//wxLuaDebuggerEvent d(wxEVT_WXLUA_DEBUGGER_PRINT, this);
//d.SetMessage(wxT("wxLuaDebugger : ") + wxLuaSocketCmdEventMsg(event_type));
//SendEvent(d);
switch (event_type)
{
case wxLUASOCKET_DEBUGGEE_EVENT_BREAK:
{
wxString fileName;
wxInt32 lineNumber = 0;
if (CheckSocketRead(
GetSocketBase()->ReadString(fileName) &&
GetSocketBase()->ReadInt32(lineNumber),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_BREAK")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_BREAK, this, lineNumber, fileName);
SendEvent(debugEvent);
}
else return -1;
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_PRINT:
{
wxString strMessage;
if (CheckSocketRead(
GetSocketBase()->ReadString(strMessage),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_PRINT")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_PRINT, this);
debugEvent.SetMessage(strMessage);
SendEvent(debugEvent);
}
else return -1;
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_ERROR:
{
wxString strMessage;
if (CheckSocketRead(
GetSocketBase()->ReadString(strMessage),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_ERROR")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_ERROR, this);
debugEvent.SetMessage(strMessage);
SendEvent(debugEvent);
}
else return -1;
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_EXIT:
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_EXIT, this);
wxPostEvent(this, debugEvent);
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_STACK_ENUM:
{
wxLuaDebugData debugData(true);
if (CheckSocketRead(
GetSocketBase()->ReadDebugData(debugData),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_STACK_ENUM")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_STACK_ENUM, this);
debugEvent.SetDebugData(-1, debugData);
SendEvent(debugEvent);
}
else return -1;
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_STACK_ENTRY_ENUM:
{
wxInt32 stackRef = 0;
wxLuaDebugData debugData(true);
if (CheckSocketRead(
GetSocketBase()->ReadInt32(stackRef) &&
GetSocketBase()->ReadDebugData(debugData),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_STACK_ENTRY_ENUM")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_STACK_ENTRY_ENUM, this);
debugEvent.SetDebugData(stackRef, debugData);
SendEvent(debugEvent);
}
else return -1;
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_TABLE_ENUM:
{
long itemNode = 0;
wxLuaDebugData debugData(true);
if (CheckSocketRead(
GetSocketBase()->ReadLong(itemNode) &&
GetSocketBase()->ReadDebugData(debugData),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_TABLE_ENUM")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_TABLE_ENUM, this);
debugEvent.SetDebugData(itemNode, debugData);
SendEvent(debugEvent);
}
else return -1;
break;
}
case wxLUASOCKET_DEBUGGEE_EVENT_EVALUATE_EXPR:
{
wxInt32 exprRef = 0;
wxString strResult;
if (CheckSocketRead(
GetSocketBase()->ReadInt32(exprRef) &&
GetSocketBase()->ReadString(strResult),
wxT("Debugger wxLUASOCKET_DEBUGGEE_EVENT_EVALUATE_EXPR")))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_EVALUATE_EXPR, this);
debugEvent.SetMessage(strResult);
debugEvent.SetDebugData(exprRef);
SendEvent(debugEvent);
}
else return -1;
break;
}
default : return -1; // don't know this event?
}
return event_type;
}
bool wxLuaDebuggerBase::CheckSocketConnected(bool send_event, const wxString& msg)
{
if (GetSocketBase() == NULL)
{
if (send_event)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED, this);
debugEvent.SetMessage(wxT("Debugger socket not created. ") + msg);
SendEvent(debugEvent);
}
return false;
}
else if (!GetSocketBase()->IsConnected())
{
if (send_event)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED, this);
debugEvent.SetMessage(wxT("Debugger socket not connected. ") + msg);
SendEvent(debugEvent);
}
return false;
}
return true;
}
bool wxLuaDebuggerBase::CheckSocketRead(bool read_ok, const wxString& msg)
{
if (!read_ok)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED, this);
debugEvent.SetMessage(wxString::Format(wxT("Failed reading from the debugger socket. %s %s\n"), msg.c_str(), GetSocketErrorMsg().c_str()));
SendEvent(debugEvent);
}
return read_ok;
}
bool wxLuaDebuggerBase::CheckSocketWrite(bool write_ok, const wxString& msg)
{
if (!write_ok)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED, this);
debugEvent.SetMessage(wxString::Format(wxT("Failed writing to the debugger socket. %s\n%s"), msg.c_str(), GetSocketErrorMsg().c_str()));
SendEvent(debugEvent);
}
return write_ok;
}
bool wxLuaDebuggerBase::DisplayStackDialog(wxWindow *parent, wxWindowID winid)
{
wxCHECK_MSG(m_stackDialog == NULL, false, wxT("Stack dialog already shown"));
m_stackDialog = new wxLuaDebuggerStackDialog(this, parent, winid);
m_stackDialog->ShowModal();
m_stackDialog->Destroy();
m_stackDialog = NULL;
return true;
}
void wxLuaDebuggerBase::OnDebugStackEnum(wxLuaDebuggerEvent &event)
{
if (GetStackDialog() != NULL)
GetStackDialog()->FillStackCombobox(event.GetDebugData());
else
event.Skip();
wxEndBusyCursor();
}
void wxLuaDebuggerBase::OnDebugStackEntryEnum(wxLuaDebuggerEvent &event)
{
if (GetStackDialog() != NULL)
GetStackDialog()->FillStackEntry(event.GetReference(), event.GetDebugData());
else
event.Skip();
wxEndBusyCursor();
}
void wxLuaDebuggerBase::OnDebugTableEnum(wxLuaDebuggerEvent &event)
{
if (GetStackDialog() != NULL)
GetStackDialog()->FillTableEntry(event.GetReference(), event.GetDebugData());
else
event.Skip();
wxEndBusyCursor();
}
void wxLuaDebuggerBase::OnEndDebugeeProcess(wxProcessEvent& event)
{
//wxPrintf(wxT("OnEndDebugeeProcess the m_debuggeeProcess %p %d exists %d\n"), m_debuggeeProcess, m_debuggeeProcessID, wxProcess::Exists(m_debuggeeProcessID)); fflush(stdout);
// The process's OnTerminate will null m_debuggeeProcess,
// but if in destructor it's already NULL and don't send event.
if (m_debuggeeProcess != NULL)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_EXIT, this);
debugEvent.SetMessage(wxString::Format(wxT("Process (%d) ended with exit code : %d"), event.GetPid(), event.GetExitCode()));
wxPostEvent(this, debugEvent);
}
event.Skip();
}
bool wxLuaDebuggerBase::KillDebuggee()
{
//wxPrintf(wxT("KillDebuggee the m_debuggeeProcess %p %d exists %d\n"), m_debuggeeProcess, m_debuggeeProcessID, wxProcess::Exists(m_debuggeeProcessID)); fflush(stdout);
if ((m_debuggeeProcess != NULL) && (m_debuggeeProcessID > 0))
{
m_debuggeeProcess->m_debugger = NULL;
m_debuggeeProcess = NULL;
//if (p->Exists(m_debuggeeProcessID)) should exist since OnTerminate hasn't been called
wxProcess::Kill(m_debuggeeProcessID, wxSIGKILL, wxKILL_CHILDREN);
}
else if (m_debuggeeProcess != NULL) // error starting process?
{
wxLuaDebuggerProcess* p = m_debuggeeProcess;
m_debuggeeProcess->m_debugger = NULL;
m_debuggeeProcess = NULL;
delete p;
}
m_debuggeeProcessID = -1;
return true;
}
#ifdef WXLUASOCKET_USE_C_SOCKET
// ----------------------------------------------------------------------------
// wxLuaDebuggerCServer::LuaThread
// ----------------------------------------------------------------------------
void *wxLuaDebuggerCServer::LuaThread::Entry()
{
m_pServer->ThreadFunction();
return 0;
}
void wxLuaDebuggerCServer::LuaThread::OnExit()
{
#if !wxCHECK_VERSION(2,9,0)
wxThread::OnExit(); // in 2.9 there is OnKill() and OnDelete()
//m_pServer->m_pThread = NULL;
#endif
}
// ----------------------------------------------------------------------------
// wxLuaDebuggerCServer
// ----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxLuaDebuggerCServer, wxLuaDebuggerBase)
wxLuaDebuggerCServer::wxLuaDebuggerCServer(int port_number)
:wxLuaDebuggerBase(port_number),
m_serverSocket(NULL), m_acceptedSocket(NULL),
m_pThread(NULL),
m_shutdown(false)
{
}
wxLuaDebuggerCServer::~wxLuaDebuggerCServer()
{
StopServer();
}
bool wxLuaDebuggerCServer::StartServer()
{
wxCHECK_MSG(m_serverSocket == NULL, false, wxT("Debugger server socket already created"));
m_shutdown = false;
m_serverSocket = new wxLuaCSocket();
m_serverSocket->m_name = wxString::Format(wxT("wxLuaDebuggerCServer::m_serverSocket (%ld)"), (long)wxGetProcessId());
if (m_serverSocket->Listen(m_port_number))
{
wxCHECK_MSG(m_pThread == NULL, false, wxT("Debugger server thread already created"));
if (!m_shutdown)
{
m_pThread = new wxLuaDebuggerCServer::LuaThread(this);
return ((m_pThread != NULL) &&
(m_pThread->Create() == wxTHREAD_NO_ERROR) &&
(m_pThread->Run() == wxTHREAD_NO_ERROR));
}
}
else
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_ERROR, this);
debugEvent.SetMessage(m_serverSocket->GetErrorMsg(true));
AddPendingEvent(debugEvent);
delete m_serverSocket;
m_serverSocket = NULL;
m_shutdown = true;
}
return false;
}
long wxLuaDebuggerCServer::StartClient()
{
wxCHECK_MSG(m_serverSocket, false, wxT("Debugger server not started"));
wxCHECK_MSG(m_pThread, false, wxT("Debugger server thread not running"));
if (!m_shutdown)
return wxLuaDebuggerBase::StartClient();
return m_debuggeeProcessID;
}
bool wxLuaDebuggerCServer::StopServer()
{
// NO checks, can always call stop server
// Set the shutdown flag
m_shutdown = true;
// try to nicely stop the socket if it exists
if (m_acceptedSocket)
{
Reset();
wxMilliSleep(500);
}
// close the session socket, but first NULL it so we won't try to use it
//m_acceptSockCritSect.Enter();
wxLuaSocket *acceptedSocket = m_acceptedSocket;
//m_acceptedSocket = NULL;
//m_acceptSockCritSect.Leave();
if (acceptedSocket != NULL)
{
if (!acceptedSocket->Shutdown(SD_BOTH))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_ERROR, this);
debugEvent.SetMessage(acceptedSocket->GetErrorMsg(true));
AddPendingEvent(debugEvent);
}
wxMilliSleep(500);
//m_acceptedSocket = NULL;
//delete acceptedSocket;
}
// close the server socket, if accepted socket created it will already
// have been deleted
if (m_serverSocket != NULL)
{
wxLuaSocket *serverSocket = m_serverSocket;
m_serverSocket = NULL;
// close the server socket by connecting to the socket, thus
// completing the 'accept'. If a client has not connected, this
// code will satisfy the accept the m_shutdown flag will be set
// so the thread will not loop and instead will just destroy the
// session socket object and return.
wxLuaSocket closeSocket;
closeSocket.m_name = wxString::Format(wxT("wxLuaDebuggerCServer closeSocket (%ld)"), (long)wxGetProcessId());
if (!closeSocket.Connect(GetNetworkName(), m_port_number) ||
!closeSocket.Shutdown(SD_BOTH))
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_ERROR, this);
debugEvent.SetMessage(serverSocket->GetErrorMsg(true));
AddPendingEvent(debugEvent);
}
wxMilliSleep(100);
delete serverSocket;
}
// One of the above two operations terminates the thread. Wait for it to stop.
if ((m_pThread != NULL) && m_pThread->IsRunning())
m_pThread->Wait();
delete m_pThread;
m_pThread = NULL;
return true;
}
void wxLuaDebuggerCServer::ThreadFunction()
{
wxCHECK_RET(m_serverSocket, wxT("Invalid server socket"));
wxCHECK_RET(m_acceptedSocket == NULL, wxT("The debugger server has already accepted a socket connection"));
m_acceptedSocket = m_serverSocket->Accept();
if (!m_acceptedSocket)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_ERROR, this);
debugEvent.SetMessage(m_serverSocket->GetErrorMsg(true));
AddPendingEvent(debugEvent);
}
else
{
m_acceptedSocket->m_name = wxString::Format(wxT("wxLuaDebuggerCServer::m_acceptedSocket (%ld)"), (long)wxGetProcessId());
wxLuaSocket *serverSocket = m_serverSocket;
m_serverSocket = NULL;
delete serverSocket;
wxThread::Sleep(500); // why ??
// Notify that a client has connected and we are ready to debug
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_CONNECTED, this);
AddPendingEvent(debugEvent);
unsigned char debug_event = 0; // wxLuaSocketDebuggeeEvents_Type
// Enter the debug loop
while (!m_pThread->TestDestroy() && !m_shutdown && m_acceptedSocket)
{
debug_event = wxLUASOCKET_DEBUGGEE_EVENT_EXIT;
{
// lock the critical section while we access it
wxCriticalSectionLocker locker(m_acceptSockCritSect);
if (m_shutdown || (m_acceptedSocket == NULL) || !m_acceptedSocket->ReadCmd(debug_event))
{
m_shutdown = true;
break;
}
}
if((debug_event == wxLUASOCKET_DEBUGGEE_EVENT_EXIT) ||
(HandleDebuggeeEvent(debug_event) != -1))
{
// don't send exit event until we've closed the socket
if (debug_event == wxLUASOCKET_DEBUGGEE_EVENT_EXIT)
{
m_shutdown = true;
break;
}
}
}
wxCriticalSectionLocker locker(m_acceptSockCritSect);
// delete the accepted socket
if (m_acceptedSocket != NULL)
{
wxLuaSocket *acceptedSocket = m_acceptedSocket;
m_acceptedSocket = NULL;
delete acceptedSocket;
}
}
// Send the exit event, now that everything is shut down
//if (debug_event == wxLUASOCKET_DEBUGGEE_EVENT_EXIT)
{
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_EXIT, this);
wxPostEvent(this, debugEvent);
}
}
wxString wxLuaDebuggerCServer::GetSocketErrorMsg()
{
wxString s;
if (m_serverSocket)
s += m_serverSocket->GetErrorMsg(true);
if (m_acceptedSocket)
s += m_acceptedSocket->GetErrorMsg(true);
return s;
}
#else // !WXLUASOCKET_USE_C_SOCKET
// ---------------------------------------------------------------------------
// wxLuaDebuggerwxSocketServer
// ---------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxLuaDebuggerwxSocketServer, wxLuaDebuggerBase)
BEGIN_EVENT_TABLE(wxLuaDebuggerwxSocketServer, wxLuaDebuggerBase)
EVT_SOCKET(ID_WXLUA_SERVER, wxLuaDebuggerwxSocketServer::OnServerEvent)
EVT_SOCKET(ID_WXLUA_SOCKET, wxLuaDebuggerwxSocketServer::OnSocketEvent)
END_EVENT_TABLE()
wxLuaDebuggerwxSocketServer::wxLuaDebuggerwxSocketServer(int port_number)
:wxLuaDebuggerBase(port_number),
m_serverSocket(NULL), m_acceptedSocket(NULL)
{
}
wxLuaDebuggerwxSocketServer::~wxLuaDebuggerwxSocketServer()
{
StopServer();
}
// Start Debugging Service
bool wxLuaDebuggerwxSocketServer::StartServer()
{
if (!m_serverSocket)
{
// Create the address - defaults to localhost:0 initially
wxIPV4address addr;
addr.Service(m_port_number);
// Create the server socket
m_serverSocket = new wxSocketServer(addr, wxSOCKET_NOWAIT|wxSOCKET_BLOCK);
m_serverSocket->SetEventHandler(*this, ID_WXLUA_SERVER);
m_serverSocket->SetNotify(wxSOCKET_CONNECTION_FLAG);
m_serverSocket->SetFlags(wxSOCKET_BLOCK);
m_serverSocket->Notify(true);
}
return m_serverSocket->Ok();
}
bool wxLuaDebuggerwxSocketServer::StopServer()
{
if (m_acceptedSocket)
{
m_acceptedSocket->GetSocket()->Notify(false);
m_acceptedSocket->Destroy();
delete m_acceptedSocket;
m_acceptedSocket = NULL;
}
if (m_serverSocket)
{
m_serverSocket->Notify(false);
m_serverSocket->Destroy(); // this deletes it too
m_serverSocket = NULL;
}
return true;
}
long wxLuaDebuggerwxSocketServer::StartClient()
{
return wxLuaDebuggerBase::StartClient();
}
wxString wxLuaDebuggerwxSocketServer::GetSocketErrorMsg()
{
wxString s;
if (m_acceptedSocket)
s += m_acceptedSocket->GetErrorMsg(true);
return s;
}
void wxLuaDebuggerwxSocketServer::OnServerEvent(wxSocketEvent& event)
{
switch(event.GetSocketEvent())
{
case wxSOCKET_CONNECTION:
{
wxSocketBase *sock = m_serverSocket->Accept(false);
if (!sock)
{
// Error
return;
}
sock->SetFlags(wxSOCKET_NOWAIT);
m_acceptedSocket = new wxLuawxSocket(sock);
m_acceptedSocket->m_port_number = m_port_number; // can't get it from wxSocketBase
m_acceptedSocket->m_name = wxString::Format(wxT("wxLuaDebuggerwxSocketServer::m_acceptedSocket (%ld)"), (long)wxGetProcessId());
// Setup Handler
sock->SetEventHandler(*this, ID_WXLUA_SOCKET);
sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
sock->Notify(true);
wxMilliSleep(500);
// Notify that a client has connected and we are ready to debug
wxLuaDebuggerEvent debugEvent(wxEVT_WXLUA_DEBUGGER_DEBUGGEE_CONNECTED, this);
AddPendingEvent(debugEvent);
break;
}
default:
// Error
break;
}
}
// Handle Commands from debugger (and lost connections)
void wxLuaDebuggerwxSocketServer::OnSocketEvent(wxSocketEvent& event)
{
wxSocketBase *sock = event.GetSocket();
// Now we process the event
switch(event.GetSocketEvent())
{
case wxSOCKET_INPUT:
{
// We disable input events, so that the test doesn't trigger
// wxSocketEvent again.
sock->SetNotify(wxSOCKET_LOST_FLAG);
unsigned char debugEvent = 0; // wxLuaSocketDebuggeeEvents_Type
if (m_acceptedSocket->ReadCmd(debugEvent))
HandleDebuggeeEvent(debugEvent);
// Enable input events again.
sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
break;
}
case wxSOCKET_LOST:
{
m_acceptedSocket->Destroy();
delete m_acceptedSocket;
m_acceptedSocket = NULL;
break;
}
default:
// Error
break;
}
}
#endif // WXLUASOCKET_USE_C_SOCKET
| [
"jjensen@workspacewhiz.com"
] | jjensen@workspacewhiz.com |
24493c0481a1bf43ef03e0bdcd38dfa52779b5d0 | 136bf577e452e57040896be2e900690dcdb1663c | /src/common/randoverride.cpp | f0803432544bb43953c930faa46358c47dc15846 | [] | no_license | WeSTManCoder/RedSource | a5ceadd6a24c8c826b162b0a3bbddfc094aaee0e | f1221d9752c61628dc0d0c4be392fbaff6107357 | refs/heads/master | 2023-03-19T20:19:00.861403 | 2020-04-23T19:33:21 | 2020-04-23T19:33:21 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 561 | cpp | //========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#if !defined(_STATIC_LINKED) || defined(_SHARED_LIB)
#include "stdlib.h"
#include "vstdlib/random.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifdef _LINUX
#define __cdecl
#endif
void __cdecl srand(unsigned int)
{
}
/*
int __cdecl rand()
{
return RandomInt( 0, 0x7fff );
}*/
#endif // !_STATIC_LINKED || _SHARED_LIB
| [
"i-sobolevskiy@mail.ru"
] | i-sobolevskiy@mail.ru |
8932bba5e2456a0fd369ab88f8a00c68f8133449 | 144e35a1b765d78d3b341f8fde2f3880e193236d | /Зубов В.С/MyDataBase/БД книги 2/материалы по FoxPro/A-06-05/Птицин Максим/ZAD08.CPP | 8e6a7984c0cfb240643a9e032adcdc6652a2555c | [] | no_license | renegator/labs | 4143b92f022ac21da0d1b70fd5121174353d9e8e | e6b2d90c3d8fd407737197748123853e6ffd5d80 | refs/heads/master | 2020-07-29T06:34:35.221888 | 2012-12-23T12:09:21 | 2012-12-23T12:09:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 631 | cpp | #include<conio.h>
#include<iostream.h>
long long nod(long long a,long long b)
{
if (a<b) return nod(b,a);
if (b==0) return a;
return nod(b,a-(a/b)*b);
}
long long nok(long long a, long long b)
{
return (a*b/nod(a,b));
}
void Zad08(void)
{
clrscr();
cout<<"Nahozdenie naibolshego obshego delitelya.\n";
cout<<"Naimenshego obshego kratnogo.\n";
cout<<"Vedite 2 chisla:\n";
long long a,b;
cout<<"a= "; cin>>a;
cout<<"b= "; cin>>b;
long long NODab=nod(a,b);
cout<<"NOD(a,b)= "<<NODab;
long long NOKab=nok(a,b);
cout<<"\nNOK(a,b)= "<<NOKab;
} | [
"radix.vinni@gmail.com"
] | radix.vinni@gmail.com |
acbcd39a71e9ecd0da01bc582df83ba72fa6cc70 | b615211e97b85df312947fed83c7d1cd68041551 | /src/coincontrol.h | cab582b2799673595b54a2e4dd33d6f5150a9638 | [
"MIT"
] | permissive | coinstew/the420coin | d8b9aa580d86e465ed26558717c5c13cfa79b768 | 54adb228bf265414efd98a2d05cbe5b6b4a909ba | refs/heads/master | 2020-03-10T13:52:37.922754 | 2018-04-14T12:33:48 | 2018-04-14T12:33:48 | 129,409,380 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,721 | h | // Copyright (c) 2011-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_COINCONTROL_H
#define BITCOIN_COINCONTROL_H
#include "primitives/transaction.h"
/** Coin Control Features. */
class CCoinControl
{
public:
CTxDestination destChange;
bool fUsePrivateSend;
bool fUseInstantSend;
//! If false, allows unselected inputs, but requires all selected inputs be used
bool fAllowOtherInputs;
//! Includes watch only addresses which match the ISMINE_WATCH_SOLVABLE criteria
bool fAllowWatchOnly;
//! Minimum the420coin fee (not per kilobyte)
CAmount nMinimumTotalFee;
CCoinControl()
{
SetNull();
}
void SetNull()
{
destChange = CNoDestination();
fAllowOtherInputs = false;
fAllowWatchOnly = false;
setSelected.clear();
fUseInstantSend = false;
fUsePrivateSend = true;
nMinimumTotalFee = 0;
}
bool HasSelected() const
{
return (setSelected.size() > 0);
}
bool IsSelected(const COutPoint& output) const
{
return (setSelected.count(output) > 0);
}
void Select(const COutPoint& output)
{
setSelected.insert(output);
}
void UnSelect(const COutPoint& output)
{
setSelected.erase(output);
}
void UnSelectAll()
{
setSelected.clear();
}
void ListSelected(std::vector<COutPoint>& vOutpoints) const
{
vOutpoints.assign(setSelected.begin(), setSelected.end());
}
private:
std::set<COutPoint> setSelected;
};
#endif // BITCOIN_COINCONTROL_H
| [
"info@coinstew.com"
] | info@coinstew.com |
0b8afe570efac6eadf45a6984a27c087e530fbd2 | 0318ede75c348b94ed5ae9689df75a19c615f102 | /src/Container.hpp | 370ec79cbc6211e6265c573e89fbe8cbd8008cf5 | [] | no_license | SamuelHenderson/RogueC | 70ea22f3ad1e4f3ec705541c3cdabf24196ae244 | 75fd45b647d4addce8e26e4841131713e47cc6c8 | refs/heads/master | 2020-06-01T19:14:54.044612 | 2015-05-29T02:53:34 | 2015-05-29T02:53:42 | 35,098,630 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 274 | hpp | class Container : public Persistent {
public:
int size; // maximum number of actors. 0=unlimited
TCODList<Actor *> inventory;
Container(int size);
~Container();
bool add(Actor *actor);
void remove(Actor *actor);
void save(TCODZip &zip);
void load(TCODZip &zip);
}; | [
"shenderson@ssmic.com"
] | shenderson@ssmic.com |
66704eb197e3fcf99999a2887bab452e33b47e38 | 4db0b990ab85ad2f255ee17734fbfba55f5c809b | /Exploration40/generate_id2.cpp | 3fe4622a30702cfbc909f15e1773c94770af05c8 | [] | no_license | darennet/Exploring-CPP-2e | f71be96580b21d19f8725e6e35c3f8fa2b9cfb19 | 1e2e3152eb3a3c923ac3886c81dec17623163270 | refs/heads/master | 2021-12-06T08:04:43.621697 | 2015-10-19T05:21:16 | 2015-10-19T05:21:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 475 | cpp | //
// Created by carmen on 24/09/2015.
//
#include "generate_id2.hpp"
// Switch to random-number as initial prefix for production code.
// short generate_id::prefix_(static_cast<short>(std::rand())));
short generate_id2::prefix_{1};;
short const generate_id2::max_counter_;
long generate_id2::next() {
if (counter_ == max_counter_) {
counter_ = 0;
} else {
++counter_;
}
return static_cast<long>(prefix_) * (max_counter_ + 1) + counter_;
}
| [
"carmen@carmengrantham.com"
] | carmen@carmengrantham.com |
41560200bc3712eb69d9bbdea3e1db22619abab9 | abf2002b030de3e205c9f92f73cc503af4321598 | /nedApp/src/CRocPlugin_v93.cpp | 53348e13732a44353683b0b53b2e475a05db1bf3 | [
"BSD-3-Clause"
] | permissive | ornl-epics/nED | ac3642044a098d2a47d73e9894b1362654c1726e | 34c8a33c9f699a2eebc6a9b436147fc1c527efc9 | refs/heads/main | 2023-08-27T14:46:50.273356 | 2021-07-15T18:16:07 | 2021-07-15T18:16:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,602 | cpp | /* CRocPlugin_v93.cpp
*
* Copyright (c) 2014 Oak Ridge National Laboratory.
* All rights reserved.
* See file LICENSE that is included with this distribution.
*
* @author Klemen Vodopivec
*/
#include "CRocPlugin.h"
/**
* @file CRocPlugin_v93.cpp
*
* CROC 9.3 parameters
*/
void CRocPlugin::createParams_v93()
{
createRegParam("VERSION", "HwRev", true, 0, 8, 0); // Hardware revision
createRegParam("VERSION", "HwVer", true, 0, 8, 8); // Hardware version
createRegParam("VERSION", "FwRev", true, 1, 8, 0); // Firmware revision (low:2,high:4)
createRegParam("VERSION", "FwVer", true, 1, 8, 8); // Firmware version (low:8,high:10)
createRegParam("VERSION", "FwYear", true, 2, 16, 0); // Firmware year
createRegParam("VERSION", "FwDay", true, 3, 8, 0); // Firmware day
createRegParam("VERSION", "FwMonth",true, 3, 8, 8); // Firmware month
// BLXXX:Det:RocXXX:| sig nam| | EPICS record description | (bi and mbbi description)
createStatusParam("Y1:Discrim", 0x0, 1, 0); // Discriminator hit on Y1 (0=no hit,1=hit)
createStatusParam("Y2:Discrim", 0x0, 1, 1); // Discriminator hit on Y2 (0=no hit,1=hit)
createStatusParam("Y3:Discrim", 0x0, 1, 2); // Discriminator hit on Y3 (0=no hit,1=hit)
createStatusParam("Y4:Discrim", 0x0, 1, 3); // Discriminator hit on Y4 (0=no hit,1=hit)
createStatusParam("Y5:Discrim", 0x0, 1, 4); // Discriminator hit on Y5 (0=no hit,1=hit)
createStatusParam("Y6:Discrim", 0x0, 1, 5); // Discriminator hit on Y6 (0=no hit,1=hit)
createStatusParam("Y7:Discrim", 0x0, 1, 6); // Discriminator hit on Y7 (0=no hit,1=hit)
createStatusParam("X1:Discrim", 0x0, 1, 7); // Discriminator hit on X1 (0=no hit,1=hit)
createStatusParam("X2:Discrim", 0x0, 1, 8); // Discriminator hit on X2 (0=no hit,1=hit)
createStatusParam("X3:Discrim", 0x0, 1, 9); // Discriminator hit on X3 (0=no hit,1=hit)
createStatusParam("X4:Discrim", 0x0, 1, 10); // Discriminator hit on X4 (0=no hit,1=hit)
createStatusParam("X5:Discrim", 0x0, 1, 11); // Discriminator hit on X5 (0=no hit,1=hit)
createStatusParam("X6:Discrim", 0x0, 1, 12); // Discriminator hit on X6 (0=no hit,1=hit)
createStatusParam("X7:Discrim", 0x0, 1, 13); // Discriminator hit on X7 (0=no hit,1=hit)
createStatusParam("X8:Discrim", 0x0, 1, 14); // Discriminator hit on X8 (0=no hit,1=hit)
createStatusParam("X9:Discrim", 0x0, 1, 15); // Discriminator hit on X9 (0=no hit,1=hit)
createStatusParam("X10:Discrim", 0x1, 1, 0); // Discriminator hit on X10 (0=no hit,1=hit)
createStatusParam("X11:Discrim", 0x1, 1, 1); // Discriminator hit on X11 (0=no hit,1=hit)
createStatusParam("G1:Discrim", 0x1, 1, 2); // Discriminator hit on G1 (0=no hit,1=hit)
createStatusParam("G2:Discrim", 0x1, 1, 3); // Discriminator hit on G2 (0=no hit,1=hit)
createStatusParam("G3:Discrim", 0x1, 1, 4); // Discriminator hit on G3 (0=no hit,1=hit)
createStatusParam("G4:Discrim", 0x1, 1, 5); // Discriminator hit on G4 (0=no hit,1=hit)
createStatusParam("G5:Discrim", 0x1, 1, 6); // Discriminator hit on G5 (0=no hit,1=hit)
createStatusParam("G6:Discrim", 0x1, 1, 7); // Discriminator hit on G6 (0=no hit,1=hit)
createStatusParam("G7:Discrim", 0x1, 1, 8); // Discriminator hit on G7 (0=no hit,1=hit)
createStatusParam("G8:Discrim", 0x1, 1, 9); // Discriminator hit on G8 (0=no hit,1=hit)
createStatusParam("G9:Discrim", 0x1, 1, 10); // Discriminator hit on G9 (0=no hit,1=hit)
createStatusParam("G10:Discrim", 0x1, 1, 11); // Discriminator hit on G10 (0=no hit,1=hit)
createStatusParam("G11:Discrim", 0x1, 1, 12); // Discriminator hit on G11 (0=no hit,1=hit)
createStatusParam("G12:Discrim", 0x1, 1, 13); // Discriminator hit on G12 (0=no hit,1=hit)
createStatusParam("G13:Discrim", 0x1, 1, 14); // Discriminator hit on G13 (0=no hit,1=hit)
createStatusParam("G14:Discrim", 0x1, 1, 15); // Discriminator hit on G14 (0=no hit,1=hit)
createStatusParam("TimeRange1DeadTime", 0x2, 1, 0); // TimeRange1 dead time cond (0=no,1=yes)
createStatusParam("TimeRange2DeadTime", 0x2, 1, 1); // TimeRange2 dead time cond (0=no,1=yes)
createStatusParam("TimeRange3DeadTime", 0x2, 1, 2); // TimeRange3 dead time cond (0=no,1=yes)
createStatusParam("TimeRange4DeadTime", 0x2, 1, 3); // TimeRange4 dead time cond (0=no,1=yes)
createStatusParam("SavedEvent", 0x2, 1, 4); // Saved event (0=no,1=yes)
createStatusParam("EvFifoAlmFull", 0x2, 1, 5); // Event FIFO almost full (0=not full,1=full)
createStatusParam("EvFifoHasData", 0x2, 1, 6); // Event FIFO has data (0=no data,1=has data)
createStatusParam("InactiveCond", 0x2, 1, 7); // Got inactive condition (0=no,1=yes)
createStatusParam("Idle", 0x2, 1, 8); // Reached idle state (0=no,1=yes)
createStatusParam("Done", 0x2, 1, 9); // Reached done state (0=no,1=yes)
createStatusParam("VetoWhileTimecnt", 0x2, 1, 10); // Got veto while timecnt check (0=no,1=yes)
createStatusParam("VetoWhileYcalc", 0x2, 1, 11); // Got veto while Y calculation (0=no,1=yes)
createStatusParam("VetoWhileXcalc", 0x2, 1, 12); // Got veto while X calculation (0=no,1=yes)
createStatusParam("VetoWhileGcalc", 0x2, 1, 13); // Got veto while G calculation (0=no,1=yes)
createStatusParam("ChFifoEmpty", 0x2, 1, 14); // Channel FIFO empty (0=not empty,1=empty)
createStatusParam("ChFifoAlmFull", 0x2, 1, 15); // Channel FIFO Almost full (0=not full,1=full)
createStatusParam("Discovered", 0x3, 1, 0); // Discovered (0=not discovered,1=discovered, archive:monitor)
createStatusParam("Configured", 0x3, 1, 1); // Configured (0=not configured [alarm],1=configured, archive:monitor)
createStatusParam("Acquiring", 0x3, 1, 2); // Acquiring data (0=not acquiring,1=acquiring, archive:monitor)
createStatusParam("ErrParity", 0x3, 1, 3); // LVDS parity error. (0=no error,1=error)
createStatusParam("ErrType", 0x3, 1, 4); // LVDS packet type error. (0=no error,1=error)
createStatusParam("ErrLength", 0x3, 1, 5); // LVDS packet length error. (0=no error,1=error)
createStatusParam("ErrTimeout", 0x3, 1, 6); // LVDS packet timeout. (0=no timeout,1=timeout)
createStatusParam("ErrNoStart", 0x3, 1, 7); // LVDS data without start. (0=no error,1=error)
createStatusParam("ErrPreStart", 0x3, 1, 8); // LVDS start before stop bit (0=no error,1=error)
createStatusParam("ErrFifoFull", 0x3, 1, 9); // LVDS FIFO went full. (0=not full,1=full)
createStatusParam("ErrNoTsync", 0x3, 1, 11); // Timestamp overflow error. (0=no error,1=error)
createStatusParam("ErrCmdBad", 0x3, 1, 12); // Unrecognized command error (0=no error,1=error)
createStatusParam("ErrCmdLength", 0x3, 1, 13); // Command length error (0=no error,1=error)
createStatusParam("ErrProgramming", 0x3, 1, 14); // WRITE_CNFG during ACQ (0=no error,1=error)
createStatusParam("OutFifoAlmostFull", 0x3, 1, 15); // Output FIFO almost full (0=not full,1=full)
createStatusParam("TclkLow", 0x4, 1, 0); // TCLK Got LOW (0=no,1=yes)
createStatusParam("TclkHigh", 0x4, 1, 1); // TCLK Got HIGH (0=no,1=yes)
createStatusParam("TsyncLow", 0x4, 1, 2); // TSYNC Got LOW (0=no,1=yes)
createStatusParam("TsyncHigh", 0x4, 1, 3); // TSYNC Got HIGH (0=no,1=yes)
createStatusParam("TxenBLow", 0x4, 1, 4); // TXEN_B Got LOW (0=no,1=yes)
createStatusParam("TxenBHigh", 0x4, 1, 5); // TXEN_B Got HIGH (0=no,1=yes)
createStatusParam("SysrstBLow", 0x4, 1, 6); // SYSRST_B Got LOW (0=no,1=yes)
createStatusParam("SysrstBHigh", 0x4, 1, 7); // SYSRST_B Got HIGH (0=no,1=yes)
createStatusParam("LvdsVerify", 0x4, 1, 8); // Detected LVDS verify (0=no,1=yes)
// BLXXX:Det:RocXXX:| sig nam | | EPICS record description | (bi and mbbi description)
createConfigParam("PositionId", '1', 0x0, 32, 0, 0); // Position index
createConfigParam("TsyncDelay", 'D', 0x0, 32, 0, 0); // TSYNC delay (scale:100,unit:ns,prec:1)
createConfigParam("TimeVetoLow", 'E', 0x0, 32, 0, 0); // Timestamp veto low (scale:100,unit:ns,prec:1)
createConfigParam("TimeVetoHigh", 'E', 0x2, 32, 0, 3333); // Timestamp veto high (scale:100,unit:ns,prec:1)
createConfigParam("FakeTrigDelay", 'E', 0x4, 16, 0, 200); // Fake trigger delay (scale:100,unit:ns,prec:1)
createConfigParam("PulseToPulseTime", 'E', 0x5, 16, 0, 0); // Pulse-to-pulse time
createConfigParam("TimeRange1", 'E', 0x6, 16, 0, 0); // Time range width #1
createConfigParam("TimeRange2", 'E', 0x7, 16, 0, 0); // Time range width #2
createConfigParam("TimeRange3", 'E', 0x8, 16, 0, 0); // Time range width #3
createConfigParam("TimeRange4", 'E', 0x9, 16, 0, 0); // Time range width #4
createConfigParam("Tp17Select", 'E', 0xA, 8, 0, 0); // TP17 select
createConfigParam("Tp18Select", 'E', 0xA, 8, 8, 0); // TP18 select
createConfigParam("DeadTime", 'E', 0xB, 16, 0, 0); // Dead time
createConfigParam("TimeRangeMin", 'E', 0xC, 13, 0, 0); // Time range count min nmin[0]
createConfigParam("TimeRangeMinCnt", 'E', 0xC, 2,13, 0); // Minimum number of valid time
createConfigParam("YMin", 'E', 0xD, 8, 0, 0); // Y minimum nmin[1]
createConfigParam("XMin", 'E', 0xD, 8, 8, 0); // X minimum nmin[2]
createConfigParam("Gcnt", 'E', 0xE, 8, 0, 0); // G minimum nmin[3]
createConfigParam("XCntMin", 'E', 0xE, 4, 8, 0); // X above nmin[2] - nmin[4]
createConfigParam("GMin", 'E', 0xE, 4,12, 0); // nongap_maxcnt_dratio
createConfigParam("PrsInfo0", 'E', 0xF, 16, 0, 0); // prs_info[47:32]
createConfigParam("PrsInfo1", 'E', 0x10, 16, 0, 0); // prs_info[63:48]
createConfigParam("PrsInfo2", 'E', 0x11, 16, 0, 0); // prs_info[79:64]
createConfigParam("TcResetMode", 'F', 0x0, 1, 0, 0); // T&C Reset mode (0=internal,1=external)
createConfigParam("TcTclkMode", 'F', 0x0, 1, 1, 0); // T&C TCLK mode (0=external,1=internal 10MHz)
createConfigParam("TcTsyncMode", 'F', 0x0, 1, 2, 0); // T&C TSYNC mode (0=external,1=internal 60Hz)
createConfigParam("TcTxEnMode", 'F', 0x0, 1, 3, 1); // T&C TX enable mode (0=external,1=internal)
createConfigParam("AcquireMode", 'F', 0x0, 2, 4, 2); // Acquire mode (0=idle,1=idle,2=normal,3=trigger)
createConfigParam("OutputMode", 'F', 0x0, 2, 6, 0); // Output mode (0=normal,1=raw [alarm],2=extended [alarm])
createConfigParam("EdgeMode", 'F', 0x0, 1, 8, 0); // Edge mode (0=low,1=falling edge)
createConfigParam("CoincidenceMode", 'F', 0x0, 2, 9, 0); // Coincidence mode (0=multiple hit,1=sections,2=both)
createConfigParam("LvdsRate", 'F', 0x0, 1,15, 0); // LVDS output rate (0=40Mhz,1=20Mhz)
// Meta-parameters needed for calculation but not available in firmware
createMetaConfigParam("XCntMax", 8, 0); // Num of X above threshold
createMetaConfigParam("YCntMax", 8, 0); // Num of Y above threshold
createMetaConfigParam("FiberCoding", 8, 0); // Type of mapping algorithm (0=v2,1=v3)
createMetaConfigParam("GGapMin1", 8, 0); // Num of X above threshold
createMetaConfigParam("GGapMin2", 8, 0); // Num of X above threshold
createMetaConfigParam("G1GapMin", 8, 0); // Gap+1 G threshold
createMetaConfigParam("X1GapMin", 8, 0); // Gap+1 X threshold
createMetaConfigParam("GMin2", 8, 0); // Num of X above threshold
createMetaConfigParam("GNoiseThreshold", 32, 8); // G noise threshold
createMetaConfigParam("XNoiseThreshold", 32, 8); // X noise threshold
createMetaConfigParam("YNoiseThreshold", 32, 8); // Y noise threshold
createMetaConfigParam("GWeight0", 8, 1); // Weight for max G found
createMetaConfigParam("GWeight1", 8, 3); // Weight for G +-1 away
createMetaConfigParam("GWeight2", 8, 5); // Weight for G +-2 away
createMetaConfigParam("GWeight3", 8, 10); // Weight for G +-3 away
createMetaConfigParam("GWeight4", 8, 10); // Weight for G +-4 away
createMetaConfigParam("GWeight5", 8, 10); // Weight for G +-5 away
createMetaConfigParam("GWeight6", 8, 10); // Weight for G +-6 away
createMetaConfigParam("GWeight7", 8, 10); // Weight for G +-7 away
createMetaConfigParam("GWeight8", 8, 10); // Weight for G +-8 away
createMetaConfigParam("GWeight9", 8, 10); // Weight for G +-9 away
createMetaConfigParam("GWeight10", 8, 10); // Weight for G +-10 away
createMetaConfigParam("GWeight11", 8, 10); // Weight for G +-11 away
createMetaConfigParam("GWeight12", 8, 10); // Weight for G +-12 away
createMetaConfigParam("GWeight13", 8, 10); // Weight for G +-13 away
createMetaConfigParam("XWeight0", 8, 2); // Weight for max X found
createMetaConfigParam("XWeight1", 8, 3); // Weight for X +-1 away
createMetaConfigParam("XWeight2", 8, 5); // Weight for X +-2 away
createMetaConfigParam("XWeight3", 8, 10); // Weight for X +-3 away
createMetaConfigParam("XWeight4", 8, 10); // Weight for X +-4 away
createMetaConfigParam("XWeight5", 8, 10); // Weight for X +-5 away
createMetaConfigParam("XWeight6", 8, 10); // Weight for X +-6 away
createMetaConfigParam("XWeight7", 8, 10); // Weight for X +-7 away
createMetaConfigParam("XWeight8", 8, 5); // Weight for X +-8 away
createMetaConfigParam("XWeight9", 8, 3); // Weight for X +-9 away
createMetaConfigParam("XWeight10", 8, 2); // Weight for X +-10 away
createMetaConfigParam("YWeight0", 8, 1); // Weight for max Y found
createMetaConfigParam("YWeight1", 8, 5); // Weight for Y +-1 away
createMetaConfigParam("YWeight2", 8, 10); // Weight for Y +-2 away
createMetaConfigParam("YWeight3", 8, 10); // Weight for Y +-3 away
createMetaConfigParam("YWeight4", 8, 10); // Weight for Y +-4 away
createMetaConfigParam("YWeight5", 8, 10); // Weight for Y +-5 away
createMetaConfigParam("YWeight6", 8, 10); // Weight for Y +-6 away
}
| [
"kvx@ornl.gov"
] | kvx@ornl.gov |
8ff27ad43772012fbe3e32f3ddf943ce98d6d723 | 95c97a35e9e2a05165896c41e50e47cc45b0ad4f | /source/lib/rbcp/rbcp.h | 80e6e5caea2a4ae7e5479af89119200439abb07d | [] | no_license | eyiliu/altel_eudaq | 75dc702f7f3c1aa11ccc23b1faa628a87527f84f | 63a1f84ed090e949bbea316918fb12c0c3e2db8c | refs/heads/master | 2023-03-28T02:37:36.184869 | 2020-11-27T01:09:52 | 2020-11-27T01:09:52 | 287,605,190 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 789 | h | #ifndef _RBCP_H_
#define _RBCP_H_ 1
#include <string>
class rbcp{
public:
struct rbcp_header{
unsigned char type;
unsigned char command;
unsigned char id;
unsigned char length;
unsigned int address;
};
rbcp(const std::string& ip, unsigned int udp, unsigned char id);
rbcp(const std::string& ip);
rbcp() = delete;
rbcp(const rbcp&) =delete;
rbcp& operator=(const rbcp&) =delete;
int rbcp_com(const char* ipAddr, unsigned int port,
struct rbcp_header* sendHeader,
char* sendData, char* recvData);
int DispatchCommand(const std::string &pszVerb,
unsigned int addrReg,
unsigned int dataReg,
std::string *recvStr
);
private:
std::string m_ip;
unsigned int m_udp;
unsigned char m_id;
};
#endif
| [
"yi.liu@desy.de"
] | yi.liu@desy.de |
c7a142e832259cb11d4c92e4b4c7c21b7e75472f | 5722258ec3ce781cd5ec13e125d71064a67c41d4 | /javafx/beans/property/ReadOnlyPropertyProxy.h | 3cb219ab574dee9a917a04d23ac1543ba349ba4e | [] | no_license | ISTE-SQA/HamsterJNIPP | 7312ef3e37c157b8656aa10f122cbdb510d53c2f | b29096d0baa9d93ec0aa21391b5a11b154928940 | refs/heads/master | 2022-03-19T11:27:03.765328 | 2019-10-24T15:06:26 | 2019-10-24T15:06:26 | 216,854,309 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,695 | h | #ifndef __javafx_beans_property_ReadOnlyPropertyProxy_H
#define __javafx_beans_property_ReadOnlyPropertyProxy_H
#include <jni.h>
#include <string>
#include "net/sourceforge/jnipp/JBooleanArrayHelper.h"
#include "net/sourceforge/jnipp/JByteArrayHelper.h"
#include "net/sourceforge/jnipp/JCharArrayHelper.h"
#include "net/sourceforge/jnipp/JDoubleArrayHelper.h"
#include "net/sourceforge/jnipp/JFloatArrayHelper.h"
#include "net/sourceforge/jnipp/JIntArrayHelper.h"
#include "net/sourceforge/jnipp/JLongArrayHelper.h"
#include "net/sourceforge/jnipp/JShortArrayHelper.h"
#include "net/sourceforge/jnipp/JStringHelper.h"
#include "net/sourceforge/jnipp/JStringHelperArray.h"
#include "net/sourceforge/jnipp/ProxyArray.h"
// includes for parameter and return type proxy classes
#include "java\lang\ObjectProxyForward.h"
namespace javafx
{
namespace beans
{
namespace property
{
class ReadOnlyPropertyProxy
{
private:
static std::string className;
static jclass objectClass;
jobject peerObject;
protected:
ReadOnlyPropertyProxy(void* unused);
virtual jobject _getPeerObject() const;
public:
static jclass _getObjectClass();
static inline std::string _getClassName()
{
return className;
}
jclass getObjectClass();
operator jobject();
// constructors
ReadOnlyPropertyProxy(jobject obj);
virtual ~ReadOnlyPropertyProxy();
ReadOnlyPropertyProxy& operator=(const ReadOnlyPropertyProxy& rhs);
// methods
/*
* Object getBean();
*/
::java::lang::ObjectProxy getBean();
/*
* String getName();
*/
::net::sourceforge::jnipp::JStringHelper getName();
};
}
}
}
#endif
| [
"steffen.becker@informatik.uni-stuttgart.de"
] | steffen.becker@informatik.uni-stuttgart.de |
d0c798d333bb056a414206bd4d6c4655ad903d78 | d7c84552dc97814f97a98fa905764c6a9cfee8fb | /cmput275/weeks/sos/soln/sos.cpp | 7e21a7d9615e706947bb74fa1494dd34110886de | [] | no_license | Hishamanik/cmput274_2019 | 6c34787b891eabea42601dd3079f24d404a6674c | 2fd885d6508b05b8a8be2cde5ea0f2c6f08e0d63 | refs/heads/main | 2023-02-04T13:54:49.140663 | 2020-12-26T12:47:16 | 2020-12-26T12:47:16 | 313,016,060 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,190 | cpp | #include <iostream>
#include <cmath> // for sqrt
using namespace std;
// Compute the greatest integer d such that d*d <= n
// (i.e. the floor of the square root).
//
// You may use this function or ignore it, it's up to you.
unsigned int integer_sqrt(unsigned int x) {
unsigned int d = sqrt(x);
// should iterate at most once, probably none
while ((d+1)*(d+1) <= x) {
++d;
}
// probably does not iterate even once
while (d*d > x) {
--d;
}
// now at this point we know (d+1)*(d+1) > x yet d*d <= x
return d;
}
int main() {
// declare your variables
uint number ;
int x =0;
int sum =0;
// read the input
cin >> number ;
// solve the problem
if (number == 0){
cout << "sum of squares" << endl ;
}
else {
unsigned root = sqrt(number);
cout << root;
for (uint32_t i=0; i<root+1; i++) {
for(uint32_t j=1; j<root+1 ; j++){
sum = (j*j)+(i*i) ;
if (sum == number){
cout << "sum of squares" << endl;
x = 1;
j= root;
i =root;
}
}
}
}
// print the answer
if (x==0 && number != 0){
cout << "not sum of squares" << endl ;
}
return 0;
}
| [
"alhishamanikjoy@gmail.com"
] | alhishamanikjoy@gmail.com |
496dafc5958cf62dbd97961fbab0d767bb2ce633 | f265a45b25004ee43c2eca4bbeea6951b2bf8e8c | /cpp/sum_mult_lt_n.cpp | c8bc85c64574679d69d76e12e8ae63ba4501565a | [] | no_license | gdsidlemath/docopt-euler | b2f57fdb8cdd495d4691923b950ed1934987b9c8 | 819b7efdb22cdbd38623ba29b557ea7af28be5dc | refs/heads/master | 2022-06-04T02:37:10.169170 | 2020-04-26T16:08:35 | 2020-04-26T16:08:35 | 259,073,894 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,215 | cpp | #include "docopt.h"
#include <iostream>
#include <string>
static const char USAGE[] =
R"(
Usage:
sum_mult_lt_n [-n number] [-j multiple1] [-k multiple2]
Options:
-n number number to calculate the sum of multiples under [default: 1000]
-j multiple1 first number to find multiples of [default: 3]
-k multiple2 second number to find multiples of [default: 5]
Description:
Project Euler Problem 1: Find the sum of all multiples of 3 or 5 below 1000
)";
int main(int argc, const char** argv) {
std::map<std::string, docopt::value> args = docopt::docopt(USAGE,
{ argv + 1, argv + argc},
true,
"Sum of Multiples Less Than N 0.1");
int number = std::stoi(args["-n"].asString());
int multiple1 = std::stoi(args["-j"].asString());
int multiple2 = std::stoi(args["-k"].asString());
int end_sum = 0;
for(int i=1; i<number; i++) {
if( i % multiple1 == 0 || i % multiple2 == 0){
end_sum += i;
}
}
std::cout << end_sum << std::endl;
return 0;
}
| [
"gsidle.math@gmail.com"
] | gsidle.math@gmail.com |
2ff5f7eaa9c2bbb6d23eae19e52435b01b7302c4 | 0dc7cca3a04006ae09db8d8475b88b7d4b67d5b5 | /ex00/Fixed.class.hpp | e2ca0489e81d12d52787eb789e77e8aaef332270 | [] | no_license | mnaji42/cpp02 | d8117a9117c45be13108a8bfe1aa46f9a186a498 | a6e691a26e0145c0c2e5fcb54c77f68feea60e37 | refs/heads/main | 2023-02-03T03:56:51.867076 | 2020-12-21T17:46:14 | 2020-12-21T17:46:14 | 323,407,552 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,196 | hpp | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Fixed.class.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mnaji <mnaji@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/02/20 22:36:11 by mnaji #+# #+# */
/* Updated: 2020/02/21 02:51:56 by mnaji ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FIXED_CLASS_HPP
# define FIXED_CLASS_HPP
# include <iostream>
class Fixed
{
private:
int _val;
static const int _bit;
public:
Fixed();
Fixed(const Fixed &f);
~Fixed();
Fixed &operator=(const Fixed &f);
int getRawBits() const;
void setRawBits(const int raw);
};
#endif
| [
"mehdi.n.1993@gmail.com"
] | mehdi.n.1993@gmail.com |
5320fd8032a99d00f3b39ece9efe0fb80f6b8286 | de8efbf6e8cbb99be76827ca2a2f9875d114229c | /code/Struct/Decorator/StringDisplay.h | c9924415f6f11e765ed0afccb5ea9bf0e09728de | [
"MIT"
] | permissive | jun-zhang/DesignPattern-1 | aad667c9960d50f0c20b0c000b0ac2add8cf68f8 | cb14c4a1f1ada49bbc7bff9dcdcdb51cae21d6f3 | refs/heads/master | 2020-06-24T15:21:10.824041 | 2019-07-26T02:51:53 | 2019-07-26T02:51:53 | 198,999,761 | 1 | 1 | MIT | 2019-07-26T10:43:41 | 2019-07-26T10:43:41 | null | UTF-8 | C++ | false | false | 547 | h | #pragma once
#include "IDisplay.h"
class StringDisplay : public IDisplay
{
public:
StringDisplay(const std::string &str) : m_str(str) {}
virtual int getRows() const override
{
return 1;
}
virtual int getColumns() const override
{
return static_cast<int>(m_str.length());
}
virtual std::string getRow(int index) const override
{
if (index == 0)
{
return m_str;
}
else
{
return {};
}
}
private:
std::string m_str;
}; | [
"wentaojia2014@163.com"
] | wentaojia2014@163.com |
c0009de6d509f0ccfb164120ffa56d5ddfd1a19f | 4a88ded5eb2a3c7cca4b3d822b6be57431db57b4 | /c-primer-plus书本练习/计算机实验1 if语句.cpp | 00b22a7e5f4e4f2b92b4766d09acf28150b65a4c | [] | no_license | yinglongwu/Cstudy | 592221003efcd0e590ae8f8a60874c7fe3efa16f | 0c2f507e31ca710b981756b0dca0508a7b11d78f | refs/heads/master | 2021-05-17T21:35:46.656597 | 2020-03-29T06:24:36 | 2020-03-29T06:24:36 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 476 | cpp | #include<stdio.h>
int main()
{
double a,b;
char c;
printf("这是一个简易的计算器，可以计算两位数的加减乘除（输入 s 可以退出使用）\n");
while (scanf("%lf%c%lf",&a,&c,&b)==3)
{
if(c=='+')
{
printf("=%g\n",a+b);
}
if(c=='-')
{
printf("=%g\n",a-b);
}
if(c=='*')
{
printf("=%g\n",a*b);
}
if(c=='/')
{
printf("=%g\n",a/b);
}
}
printf("本次服务已结束！");
return 0;
}
| [
"18815619123@163.com"
] | 18815619123@163.com |
68baa0a81a31328b5e9ffcf23e8f628964264a4d | 855da48165e70cd07c3f184714a9c166c537ec35 | /CardDefence/Classes/TowerPosEditorOperateLayer.h | 4362dc5ba726a9bc53fa604ce6c416e541f7fe5e | [] | no_license | wingkit/N001V150303MyLab | 4af547b9fa68cf4b4cca92023baff61e14a46490 | c04538cd1568a7b0558681d2b03bd83976606063 | refs/heads/master | 2016-09-05T17:40:30.456285 | 2015-06-18T16:07:11 | 2015-06-18T16:07:25 | 31,596,585 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 1,558 | h | #ifndef _TowerPosEditorOperateLayer_H_
#define _TowerPosEditorOperateLayer_H_
#include "cocos2d.h"
#include "editor-support/cocostudio/CCSGUIReader.h"
#include "ui/CocosGUI.h"
<<<<<<< HEAD
#include "extensions/cocos-ext.h"
=======
#include "cocos-ext.h"
>>>>>>> 242d9fd9e2218bb56c21948853acb0e3a3cae294
USING_NS_CC;
USING_NS_CC_EXT;
using namespace cocos2d::ui;
using namespace cocostudio;
class TowerPosEditorLayer;
class TowerPosEditorOperateLayer : public Layer{
public:
TowerPosEditorOperateLayer();
~TowerPosEditorOperateLayer();
static TowerPosEditorOperateLayer* create(TowerPosEditorLayer* layer);
virtual bool init(TowerPosEditorLayer* layer);
void draw(Renderer *renderer, const kmMat4 &transform, bool transformUpdated);
private:
// 编辑层
TowerPosEditorLayer* m_editorLayer;
// 输出按钮
void outputBtnOnClick(Ref*, TouchEventType type);
// 改变模式按钮
void changeModeBtnOnClick(Ref*, TouchEventType type);
// 下一关按钮
void nextLevelBtnOnClick(Ref*, TouchEventType type);
// 上一关按钮
void preLevelBtnOnClick(Ref*, TouchEventType type);
<<<<<<< HEAD
// 返回按钮
void backBtnOnClick(Ref*, TouchEventType type);
// 定时器操作Label
void scheduleOnceLab(float dt);
// 绘制函数
void onDraw(const kmMat4 &transform, bool transformUpdated);
CustomCommand _customCommand;
// 保存返回
LabelTTF* m_labLog;
=======
// 绘制函数
void onDraw(const kmMat4 &transform, bool transformUpdated);
CustomCommand _customCommand;
>>>>>>> 242d9fd9e2218bb56c21948853acb0e3a3cae294
};
#endif | [
"525424725@qq.com"
] | 525424725@qq.com |
8a2cc511a8354e26e5f28f69060acad80a0c1501 | b0c876f37344cc8d899eeb428d0da6c301ff93cd | /core/samplers/stratified.hpp | 3d8ce2630015e91f1e8c71e1a646ae88d73046f7 | [] | no_license | marcopetreri/path-tracer | 1ba3df9022607b9070e2dda1895fe69cd158e1be | af2a14c33c3d6116c13f9e41402d73a463a8a476 | refs/heads/develop | 2021-07-10T14:15:03.727367 | 2019-03-24T11:43:01 | 2019-03-24T11:43:01 | 148,894,419 | 0 | 2 | null | 2019-03-24T11:43:02 | 2018-09-15T11:03:06 | C++ | UTF-8 | C++ | false | false | 524 | hpp | #ifndef _STRATIFIED_SAMPLER_
#define _STRATIFIED_SAMPLER_
#include "sampler.hpp"
#include "../utilities/math.hpp"
class StratifiedSampler : public Sampler{
public:
StratifiedSampler(): Sampler(), current(0), n(sqrt(samples)), invN(1.f/n), invSamples(1.f/samples){}
StratifiedSampler(int s): Sampler(s), current(0), n(sqrt(s)), invN(1.f/n), invSamples(1.f/samples){}
virtual ~StratifiedSampler(){}
void nextSample(){
++current %= samples;
}
u_int current;
u_int n;
float invN, invSamples;
};
#endif
| [
"pepello92@gmail.com"
] | pepello92@gmail.com |
0329938877df383c8e3ffab424a2fa5f4240911e | 553b9af9c0109abcac22a5af59ce3be3c79ba4b6 | /402. Remove K Digits Solution1.cpp | 4da12e1dfa3e4367a8651b7cd6220ef99ed60809 | [] | no_license | yeopgi/LeetCode | 3628b51b7cf91267f5cf2e4cb4c183dc71287ff9 | db846337344bd5cb8fff209387b27b22c50093cc | refs/heads/master | 2023-02-04T21:26:09.328078 | 2020-12-18T05:46:16 | 2020-12-18T05:46:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 685 | cpp | class Solution {
public:
// Time: O(n)
// Space: O(n)
string removeKdigits(string num, int k) {
// greedy
k = min(k, (int)num.size());
string res;
for (auto c : num) {
while (k && res.size() && res.back() > c) {
--k;
res.pop_back();
}
res += c;
}
// delete the last k chars since the stack monotonically increasing
while (k--) res.pop_back();
// remove all leading zeros
int i = 0;
while (i < res.size() && res[i] == '0') ++i;
if (i == res.size()) return "0";
return res.substr(i);
}
};
| [
"zyjiang@utexas.edu"
] | zyjiang@utexas.edu |
d61f563757d036e0c04a714b12818b51da223c14 | 7759a90c5704266f8ecd74eefe6012b1e4cf1d30 | /tkrzw_dbm_tree_impl.cc | 3c81520101291adb5dc9b3fd1be7c7d8070cbf50 | [
"Apache-2.0"
] | permissive | maiha/tkrzw | 64bcfd3a74485c5b8b2f7f1663e1c432ef99048d | ddb989148ec975ae7537bbd690f43565143d30af | refs/heads/master | 2022-11-29T13:42:47.797736 | 2020-07-19T14:19:28 | 2020-07-19T14:19:28 | 280,895,693 | 0 | 0 | Apache-2.0 | 2020-07-19T15:35:32 | 2020-07-19T15:35:31 | null | UTF-8 | C++ | false | false | 4,238 | cc | /*************************************************************************************************
* Implementation components for the tree database manager
*
* Copyright 2020 Google LLC
* 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
* https://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 "tkrzw_dbm.h"
#include "tkrzw_dbm_tree_impl.h"
#include "tkrzw_file.h"
#include "tkrzw_sys_config.h"
namespace tkrzw {
std::string_view TreeRecord::GetKey() const {
const char* rp = reinterpret_cast<const char*>(this) + sizeof(*this);
return std::string_view(rp, key_size);
}
std::string_view TreeRecord::GetValue() const {
const char* rp = reinterpret_cast<const char*>(this) + sizeof(*this) + key_size;
return std::string_view(rp, value_size);
}
int32_t TreeRecord::GetSerializedSize() const {
return SizeVarNum(key_size) + key_size + SizeVarNum(value_size) + value_size;
}
TreeRecord* CreateTreeRecord(std::string_view key, std::string_view value) {
TreeRecord* rec =
static_cast<TreeRecord*>(xmalloc(sizeof(TreeRecord) + key.size() + value.size()));
rec->key_size = key.size();
rec->value_size = value.size();
char* wp = reinterpret_cast<char*>(rec) + sizeof(*rec);
std::memcpy(wp, key.data(), key.size());
std::memcpy(wp + key.size(), value.data(), value.size());
return rec;
}
TreeRecord* ModifyTreeRecord(TreeRecord* record, std::string_view new_value) {
if (static_cast<int32_t>(new_value.size()) > record->value_size) {
record = static_cast<TreeRecord*>(xrealloc(
record, sizeof(TreeRecord) + record->key_size + new_value.size()));
}
record->value_size = new_value.size();
char* wp = reinterpret_cast<char*>(record) + sizeof(*record) + record->key_size;
std::memcpy(wp, new_value.data(), new_value.size());
return record;
}
void FreeTreeRecord(TreeRecord* record) {
xfree(record);
}
void FreeTreeRecords(std::vector<TreeRecord*>* records) {
for (auto* rec : *records) {
xfree(rec);
}
}
TreeRecordOnStack::TreeRecordOnStack(std::string_view key) {
const int32_t size = sizeof(TreeRecord) + key.size();
buffer = size <= STACK_BUFFER_SIZE ? stack : new char[size];
record = reinterpret_cast<TreeRecord*>(buffer);
record->key_size = key.size();
char* wp = reinterpret_cast<char*>(record) + sizeof(*record);
std::memcpy(wp, key.data(), key.size());
}
TreeRecordOnStack::~TreeRecordOnStack() {
if (buffer != stack) {
delete[] buffer;
}
}
std::string_view TreeLink::GetKey() const {
const char* rp = reinterpret_cast<const char*>(this) + sizeof(*this);
return std::string_view(rp, key_size);
}
int32_t TreeLink::GetSerializedSize(int32_t page_id_width) const {
return SizeVarNum(key_size) + key_size + page_id_width;
}
TreeLink* CreateTreeLink(std::string_view key, int64_t child) {
TreeLink* link = static_cast<TreeLink*>(xmalloc(sizeof(TreeLink) + key.size()));
link->key_size = key.size();
link->child = child;
char* wp = reinterpret_cast<char*>(link) + sizeof(*link);
std::memcpy(wp, key.data(), key.size());
return link;
}
void FreeTreeLink(TreeLink* link) {
xfree(link);
}
void FreeTreeLinks(std::vector<TreeLink*>* links) {
for (auto* link : *links) {
xfree(link);
}
}
TreeLinkOnStack::TreeLinkOnStack(std::string_view key) {
const int32_t size = sizeof(TreeLink) + key.size();
buffer = size <= STACK_BUFFER_SIZE ? stack : new char[size];
link = reinterpret_cast<TreeLink*>(buffer);
link->key_size = key.size();
char* wp = reinterpret_cast<char*>(link) + sizeof(*link);
std::memcpy(wp, key.data(), key.size());
}
TreeLinkOnStack::~TreeLinkOnStack() {
if (buffer != stack) {
delete[] buffer;
}
}
} // namespace tkrzw
// END OF FILE
| [
"hirarin@gmail.com"
] | hirarin@gmail.com |
5b309bba690b19e6c8f46787e4cdd0ea5f6b74d9 | 8543d49cec19c9be3f6ea9068c8c31316476f753 | /src/rpc/client.cpp | 384396685325257ce488f5afabca075bb3411732 | [
"MIT"
] | permissive | blackbearcoin/b2c | 55a9441c8287f9a61c1d43e4df54bae4a23a7041 | d0f916633d9d77e234bc7984b9a064ab9ffa50b4 | refs/heads/main | 2023-05-14T00:49:48.454131 | 2021-03-16T03:26:50 | 2021-03-16T03:26:50 | 334,512,601 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,952 | cpp | // Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2018 The PIVX developers
// Copyright (c) 2019 The Black Bear Coin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "rpc/client.h"
#include "rpc/protocol.h"
#include "ui_interface.h"
#include "util.h"
#include <set>
#include <stdint.h>
#include <boost/algorithm/string/case_conv.hpp> // for to_lower()
#include <univalue.h>
using namespace std;
class CRPCConvertParam
{
public:
std::string methodName; //! method whose params want conversion
int paramIdx; //! 0-based idx of param to convert
};
// ***TODO***
static const CRPCConvertParam vRPCConvertParams[] =
{
{"stop", 0},
{"setmocktime", 0},
{"getaddednodeinfo", 0},
{"setgenerate", 0},
{"setgenerate", 1},
{"getnetworkhashps", 0},
{"getnetworkhashps", 1},
{"sendtoaddress", 1},
{"sendtoaddressix", 1},
{"settxfee", 0},
{"getreceivedbyaddress", 1},
{"getreceivedbyaccount", 1},
{"listreceivedbyaddress", 0},
{"listreceivedbyaddress", 1},
{"listreceivedbyaddress", 2},
{"listreceivedbyaccount", 0},
{"listreceivedbyaccount", 1},
{"listreceivedbyaccount", 2},
{"getbalance", 1},
{"getbalance", 2},
{"getblockhash", 0},
{"move", 2},
{"move", 3},
{"sendfrom", 2},
{"sendfrom", 3},
{"listtransactions", 1},
{"listtransactions", 2},
{"listtransactions", 3},
{"listaccounts", 0},
{"listaccounts", 1},
{"walletpassphrase", 1},
{"walletpassphrase", 2},
{"getblocktemplate", 0},
{"listsinceblock", 1},
{"listsinceblock", 2},
{"sendmany", 1},
{"sendmany", 2},
{"addmultisigaddress", 0},
{"addmultisigaddress", 1},
{"createmultisig", 0},
{"createmultisig", 1},
{"listunspent", 0},
{"listunspent", 1},
{"listunspent", 2},
{"listunspent", 3},
{"getblock", 1},
{"getblockheader", 1},
{"gettransaction", 1},
{"getrawtransaction", 1},
{"createrawtransaction", 0},
{"createrawtransaction", 1},
{"signrawtransaction", 1},
{"signrawtransaction", 2},
{"sendrawtransaction", 1},
{"sendrawtransaction", 2},
{"gettxout", 1},
{"gettxout", 2},
{"lockunspent", 0},
{"lockunspent", 1},
{"importprivkey", 2},
{"importaddress", 2},
{"verifychain", 0},
{"verifychain", 1},
{"keypoolrefill", 0},
{"getrawmempool", 0},
{"estimatefee", 0},
{"estimatepriority", 0},
{"prioritisetransaction", 1},
{"prioritisetransaction", 2},
{"setban", 2},
{"setban", 3},
{"spork", 1},
{"reservebalance", 0},
{"reservebalance", 1},
{"setstakesplitthreshold", 0},
{"autocombinerewards", 0},
{"autocombinerewards", 1},
{"getaccumulatorvalues", 0},
{"getfeeinfo", 0}
};
class CRPCConvertTable
{
private:
std::set<std::pair<std::string, int> > members;
public:
CRPCConvertTable();
bool convert(const std::string& method, int idx)
{
return (members.count(std::make_pair(method, idx)) > 0);
}
};
CRPCConvertTable::CRPCConvertTable()
{
const unsigned int n_elem =
(sizeof(vRPCConvertParams) / sizeof(vRPCConvertParams[0]));
for (unsigned int i = 0; i < n_elem; i++) {
members.insert(std::make_pair(vRPCConvertParams[i].methodName,
vRPCConvertParams[i].paramIdx));
}
}
static CRPCConvertTable rpcCvtTable;
/** Non-RFC4627 JSON parser, accepts internal values (such as numbers, true, false, null)
* as well as objects and arrays.
*/
UniValue ParseNonRFCJSONValue(const std::string& strVal)
{
UniValue jVal;
if (!jVal.read(std::string("[")+strVal+std::string("]")) ||
!jVal.isArray() || jVal.size()!=1)
throw runtime_error(string("Error parsing JSON:")+strVal);
return jVal[0];
}
/** Convert strings to command-specific RPC representation */
UniValue RPCConvertValues(const std::string &strMethod, const std::vector<std::string> &strParams)
{
UniValue params(UniValue::VARR);
for (unsigned int idx = 0; idx < strParams.size(); idx++) {
const std::string& strVal = strParams[idx];
if (!rpcCvtTable.convert(strMethod, idx)) {
// insert string value directly
params.push_back(strVal);
} else {
// parse string as JSON, insert bool/number/object/etc. value
params.push_back(ParseNonRFCJSONValue(strVal));
}
}
return params;
}
| [
"61999161+f0rgoot@users.noreply.github.com"
] | 61999161+f0rgoot@users.noreply.github.com |
4864f480a0e84b4f34d8941af8b964ef8275c7e0 | 98c0baa6bfdd181adf8fa1d4107cf8ea1871a242 | /Chakra3_017a0d6_20170731/tv-ap/dvb/ui2/res960x540xI8/ZUI_EPOP_alphatable_c.inl | ba663a958404e0948eb332063bc0b2bd70026936 | [] | no_license | excorp/mstar | 2e83dd25d1f36e69399fd3b632f52fbaacaf89f4 | 5d447aa5b54b60ede27d5fda42d481efa4b10ff8 | refs/heads/master | 2022-02-18T16:36:06.398420 | 2018-06-13T00:26:43 | 2018-06-13T00:26:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,444 | inl | ////////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2006-2010 MStar Semiconductor, Inc.
// All rights reserved.
//
// Unless otherwise stipulated in writing, any and all information contained
// herein regardless in any format shall remain the sole proprietary of
// MStar Semiconductor Inc. and be kept in strict confidence
// (''MStar Confidential Information'') by the recipient.
// Any unauthorized act including without limitation unauthorized disclosure,
// copying, use, reproduction, sale, distribution, modification, disassembling,
// reverse engineering and compiling of the contents of MStar Confidential
// Information is unlawful and strictly prohibited. MStar hereby reserves the
// rights to any and all damages, losses, costs and expenses resulting therefrom.
//
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// This file is automatically generated by SkinTool [Version:0.2.3][Build:Dec 28 2015 14:35:41]
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// Window Alpha Data List (dup reduce) (HWND, normal, focused, disable)
WINDOWALPHADATA _MP_TBLSEG _GUI_WindowsAlphaList_Zui_Epop[] =
{
{ HWND_INVALID, 255, 255, 255 }, //General case
};
| [
"xuzemin@live.cn"
] | xuzemin@live.cn |
766d5624b82eec854730b02abb5fceccbe1bc663 | 084006eb442b60b82b3d85d61a3b53d21c5c8855 | /shared/ClanLib-2.0/Sources/API/Core/Text/console.h | ca75c80cc93f1746dd018a69251cb33779d70433 | [
"XFree86-1.1",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | SethRobinson/proton | 7aadcb38bc676c136dce01b8f6773fd75fa33d55 | 6b1474e75a2acf48d848c70fcb043ce8223001a9 | refs/heads/master | 2023-08-31T11:04:21.575522 | 2023-08-29T07:44:50 | 2023-08-29T07:44:50 | 142,253,855 | 81 | 31 | NOASSERTION | 2023-08-07T22:02:41 | 2018-07-25T05:55:38 | C++ | UTF-8 | C++ | false | false | 8,817 | h | /*
** ClanLib SDK
** Copyright (c) 1997-2010 The ClanLib Team
**
** 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.
**
** Note: Some of the libraries ClanLib may link to may have additional
** requirements or restrictions.
**
** File Author(s):
**
** Magnus Norddahl
** Kenneth Gangstoe
** Mark Page
*/
/// \addtogroup clanCore_Text clanCore Text
/// \{
#pragma once
// 'kbhit' was declared deprecated
#ifdef WIN32
#pragma warning(disable: 4996)
#endif
#include "../api_core.h"
#include "string_format.h"
#include "string_help.h"
#ifdef WIN32
#include <conio.h>
#else
#include <unistd.h>
#endif
/// \brief Console access helper class.
///
/// \xmlonly !group=Core/Text! !header=core.h! \endxmlonly
class CL_Console
{
/// \name Operations
/// \{
public:
/// \brief Writes text to the console window.
static void write(const CL_StringRef &text);
template <class Arg1>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
static void write(const CL_StringRef &format, Arg1 arg1)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
write(f.get_result());
}
template <class Arg1, class Arg2>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
static void write(const CL_StringRef &format, Arg1 arg1, Arg2 arg2)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
write(f.get_result());
}
template <class Arg1, class Arg2, class Arg3>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
static void write(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
write(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
static void write(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
write(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
/// \param arg5 = Arg5
static void write(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
f.set_arg(arg5);
write(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
/// \param arg5 = Arg5
/// \param arg6 = Arg6
static void write(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
f.set_arg(arg5);
f.set_arg(arg6);
write(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
/// \brief Write
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
/// \param arg5 = Arg5
/// \param arg6 = Arg6
/// \param arg7 = Arg7
static void write(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
f.set_arg(arg5);
f.set_arg(arg6);
f.set_arg(arg7);
write(f.get_result());
}
/// \brief Writes text to the console window and then advances to a new line.
static void write_line(const CL_StringRef &text)
{
write(text);
#ifdef WIN32
write("\r\n");
#else
write("\n");
#endif
}
template <class Arg1>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
static void write_line(const CL_StringRef &format, Arg1 arg1)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
write_line(f.get_result());
}
template <class Arg1, class Arg2>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
static void write_line(const CL_StringRef &format, Arg1 arg1, Arg2 arg2)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
write_line(f.get_result());
}
template <class Arg1, class Arg2, class Arg3>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
static void write_line(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
write_line(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
static void write_line(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
write_line(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
/// \param arg5 = Arg5
static void write_line(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
f.set_arg(5, arg5);
write_line(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
/// \param arg5 = Arg5
/// \param arg6 = Arg6
static void write_line(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
f.set_arg(5, arg5);
f.set_arg(6, arg6);
write_line(f.get_result());
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
/// \brief Write line
///
/// \param format = String Ref
/// \param arg1 = Arg1
/// \param arg2 = Arg2
/// \param arg3 = Arg3
/// \param arg4 = Arg4
/// \param arg5 = Arg5
/// \param arg6 = Arg6
/// \param arg7 = Arg7
static void write_line(const CL_StringRef &format, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7)
{
CL_StringFormat f(format);
f.set_arg(1, arg1);
f.set_arg(2, arg2);
f.set_arg(3, arg3);
f.set_arg(4, arg4);
f.set_arg(5, arg5);
f.set_arg(6, arg6);
f.set_arg(7, arg7);
write_line(f.get_result());
}
/// \brief Block until a key is pressed in the console window.
///
/// This function does not do anything on Linux
static void wait_for_key();
/// \}
};
/// \}
| [
"seth@rtsoft.com"
] | seth@rtsoft.com |
8155fb76dee329ed01ddd318a95d38226f830eeb | 786cf17c550d155dc8b879e32cfc5499995863b0 | /cs251/Assignments/Programs/Prog2/src/GridWorldClass/district.h | 720a8a13892b2da447ae9f5df1f832097ae9196c | [] | no_license | hbudzik/bertvm.cs.uic.edu | 3f33c93b59b7dc96c45536751dba50fe94215327 | cfa18dba381d010305d35c70f1689c8d7e175894 | refs/heads/master | 2022-02-26T08:10:16.387046 | 2019-09-11T03:20:46 | 2019-09-11T03:20:46 | 120,971,117 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 739 | h | #include <vector>
#include <iostream>
using namespace std;
class district
{
private:
//Struct for members in the district
struct NODE {
int id;
NODE* next = nullptr;
NODE* prev = nullptr;
};
public:
//initializes a class
district()
{
//(debugg == true) ? std::cout << "calling.. GridWord::GridWorld(" << nrows << ", " << ncols << ")\n" : std::cout << " ";
init();
}
~district()
{
}
private:
//pointers for the front and back NODE of the DLL
NODE* front;
NODE* back;
int population = 0; //current population in this district
//helper functions
void init()
{
front = nullptr;
back = nullptr;
}
};
| [
"hubertbudmobile@gmail.com"
] | hubertbudmobile@gmail.com |
db4d46bb79a086b8a6c233020797c9cc8f949a32 | 8f886002aaa3c2a9699d2a26d667064b727f8e58 | /DirectionalLight.h | 0d9cb9a0a78d65fff2866dcb7748459f75acb290 | [] | no_license | unidentifiedFlan-zz/GameEngine | b39baa7cc46b159382ea8b08ca537d668a7e070f | 6405687b221ab2c816e8e5502c9114fcd74cc580 | refs/heads/main | 2023-06-08T03:20:48.723543 | 2021-02-21T15:01:13 | 2021-02-21T15:01:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 127 | h | #pragma once
#include "Light.h"
class DirectionalLight :public Light
{
public:
DirectionalLight();
glm::vec3 direction;
}; | [
"scday546@gmail.com"
] | scday546@gmail.com |
ef77d0cb9e62c817a5a91048597339be0db46a56 | ffa427f7667d7fc05c4e872966cbb272242d3c19 | /other/cpsco/2019s1/c/main.cpp | 1bffa73419b6b6aa51ea38ae4d1ad9331d4e36fb | [] | no_license | kubonits/atcoder | 10fb6c9477c9b5ff7f963224a2c851aaf10b4b65 | 5aa001aab4aaabdac2de8c1abd624e3d1c08d3e3 | refs/heads/master | 2022-10-02T06:42:32.535800 | 2022-08-29T15:44:55 | 2022-08-29T15:44:55 | 160,827,483 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 520 | cpp | #include <algorithm>
#include <iostream>
using namespace std;
int n, k, a[40], ans;
void dfs(int x, int y, int z) {
if (x == n && y == k) {
int res = 0;
while (z) {
res += z % 5 + z % 10 / 5;
z /= 10;
}
ans = min(ans, res);
return;
}
if (y < k) {
dfs(x + 1, y + 1, z + a[x]);
}
if (y + n - x >= k) {
dfs(x + 1, y, z);
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ans = 1000000000;
dfs(0, 0, 0);
cout << ans << endl;
} | [
"kouhei.08.10.09.s@gmail.com"
] | kouhei.08.10.09.s@gmail.com |
fe318c904077ecba0f417f6fed9ff5b2ba54db25 | 1c8c2333675cb6c2a36326944ba8997cf3c5c752 | /assignment1/CLA_gen.cpp | 4d07e3f4623c5015365cf36397372ce2ed6b86fe | [] | no_license | nifey/cad_for_vlsi | 0fb9a51531d50969a507f7b3782efa56de098478 | 3d102dd74aca978039c7c6dd755e176e09f84ee4 | refs/heads/master | 2023-01-23T04:56:44.729975 | 2020-12-07T09:58:19 | 2020-12-07T09:58:19 | 304,353,767 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,349 | cpp | #include<iostream>
#include<fstream>
using namespace std;
// Function to find the log to base 2
int log2(int n) {
if (n==1) {
return 0;
} else {
return log2(n/2) + 1;
}
}
int main(int argc, char** argv) {
if (argc < 3) {
cout << "Usage: ./a.out n output_filename" << endl;
return 0;
}
int n = atoi(argv[1]);
string filename(argv[2]);
cout << "Generating a Carry lookahead adder for " << n << " bits" << endl;
cout << "Output file: " << filename << endl;
// Open the file to write output
ofstream outfile;
outfile.open(filename, ios::out | ios::trunc);
if (!outfile.is_open()) {
cout << "Error: Cannot open file " << filename << " for writing" << endl;
return 0;
}
// This is the number of reduction stages required
int num_stages = log2(n) + 1;
// Print the status module
// The status module generates the status initially
outfile << "module status(a, b, st);" << endl;
outfile << "input a, b;" << endl;
outfile << "output [1:0] st;" << endl;
outfile << "assign #2 st[1] = a & b;" << endl;
outfile << "assign #2 st[0] = a | b;" << endl;
outfile << "endmodule" << endl;
outfile << endl;
// Print the reduce module
// The reduce module is the star operator
outfile << "module reduce(sta, stb, stc);" << endl;
outfile << "input [1:0] sta, stb;" << endl;
outfile << "output [1:0] stc;" << endl;
outfile << "assign #2 stc[0] = stb[1] | (sta[0] & stb[0]) ;" << endl;
outfile << "assign #2 stc[1] = stb[1] | (sta[1] & stb[0]) ;" << endl;
outfile << "endmodule" << endl;
outfile << endl;
// Now print the CLA module
outfile << "module CLA (a, b, c, cout);" << endl;
outfile << "input [" << n-1 << ":0] a, b;" << endl;
outfile << "output [" << n-1 << ":0] c;" << endl;
outfile << "output cout;" << endl;
// We need (num_stages + 1) wire arrays to hold intermediate status values during reduction
outfile << "wire [1:0] ";
for (int i=0; i <= num_stages ; i++) {
outfile << "st" << i << "[" << n-1 << ":0]";
if (i != num_stages) {
outfile << ", ";
}
}
outfile << ";" << endl;
outfile << endl;
// Phase 1: Calculate initial status bits
for (int i=0; i<n; i++) {
outfile << "status s" << i << "(a[" << i << "], b[" << i << "], st0[" << i << "]);" << endl;
}
outfile << endl;
// Phase 2: Reduction stages
int diff = 1;
for (int i=1; i <= num_stages; i++) {
// Values that are already reduced
int j=0;
for (; j < diff-1; j++) {
outfile << "assign st" << i << "[" << j <<"] = st" << i-1 << "[" << j <<"];" << endl;
}
// Special case: when prev status is Kill (by default)
outfile << "reduce R"<< i-1 << "_" << j <<"(2'h0, st" << i-1 << "[" << j << "], st" << i << "[" << j << "]);" << endl;
// Normal case reduction
for (j++; j < n; j++) {
outfile << "reduce R"<< i-1 << "_" << j <<"(st" << i-1 << "[" << j-diff << "], st" << i-1 << "[" << j << "], st" << i << "[" << j << "]);" << endl;
}
outfile << endl;
diff *= 2;
}
// Phase 3: Perform final addition
outfile << "assign #6 c[0] = a[0] ^ b[0] ^ 0;" << endl;
for (int i=1; i<n; i++) {
outfile << "assign #6 c[" << i << "] = a[" << i << "] ^ b[" << i << "] ^ st"<< num_stages << "[" << i-1 << "][0];" << endl;
}
outfile << "assign cout = st" << num_stages << "[" << n-1 << "][0];" << endl;
outfile << endl;
outfile << "endmodule" << endl;
// Close the output file
outfile.close();
}
| [
"nihaal.an@gmail.com"
] | nihaal.an@gmail.com |
2bee951a66dc711aad23b375c11c1a0bfeb0ff47 | 724ab4b95af7786587d442f206f0c3a895b2e2c1 | /chinko_bot/types/game/context/roleplay/AlternativeMonstersInGroupLightInformations.h | fa6f5049715392fc8f15727c7ea0601ae836e9df | [] | no_license | LaCulotte/chinko_bot | 82ade0e6071de4114cc56b1eb6085270d064ccb1 | 29aeba90638d0f2fe54d1394c1c9a2f63524e50e | refs/heads/master | 2023-02-04T21:15:20.344124 | 2020-12-26T08:55:00 | 2020-12-26T08:55:00 | 270,402,722 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,120 | h | #ifndef ALTERNATIVEMONSTERSINGROUPLIGHTINFORMATIONS_H
#define ALTERNATIVEMONSTERSINGROUPLIGHTINFORMATIONS_H
#include "NetworkType.h"
#include "MonsterInGroupLightInformations.h"
class AlternativeMonstersInGroupLightInformations : public NetworkType {
public:
// Constructor
AlternativeMonstersInGroupLightInformations() {};
// Copy constructor
AlternativeMonstersInGroupLightInformations(const AlternativeMonstersInGroupLightInformations& other) = default;
// Copy operator
AlternativeMonstersInGroupLightInformations& operator=(const AlternativeMonstersInGroupLightInformations& other) = default;
// Destructor
~AlternativeMonstersInGroupLightInformations() = default;
virtual unsigned int getId() override { return typeId; };
static const unsigned int typeId = 4329;
// Turns raw data into the usable data (type's attributes)
virtual bool deserialize(shared_ptr<MessageDataBuffer> input) override;
// Turns the type's attributes into raw data
virtual bool serialize(shared_ptr<MessageDataBuffer> output) override;
vector<MonsterInGroupLightInformations> monsters;
int playerCount = 0;
};
#endif | [
"negeko-inscriptions@hotmail.com"
] | negeko-inscriptions@hotmail.com |
8a2fa3f0f69d9edf253da7cf44c08dad6f5a4b6a | aa64518fd77bbe4a41b03409bfa283641c09b580 | /palindromeLinkedList.cpp | 5ea0eff5bb8df601699410af066c0ee87c54fac8 | [] | no_license | haitong/myleetcode | 64c107eaa5b5f9b2218438c7a148e3c2eacec90c | 7e16e340dacd5b00ebc3a047101fe1026e5fb2d2 | refs/heads/master | 2016-09-06T08:57:55.835488 | 2015-07-12T19:03:29 | 2015-07-12T19:03:29 | 33,004,320 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,424 | cpp | /*
Given a singly linked list, determine if it is a palindrome.
Follow up:
Could you do it in O(n) time and O(1) space?
*/
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
void reverseList(ListNode * head, ListNode * end){
ListNode * start = nullptr, * front = head, * tmp;
while(start != end){
tmp = front->next;
front->next = start;
start = front;
front = tmp;
}
}
bool isPalindrome(ListNode* head) {
if(head == nullptr || head->next == nullptr) return true;
ListNode * fast = head->next;
ListNode * slow = head;
bool middle = true;
while(fast->next != nullptr){
fast = fast->next;
if(fast->next != nullptr){
fast = fast->next;
}
else{
middle = false;
break;
}
slow = slow->next;
}
if(middle) fast = slow->next;
else fast = slow->next->next;
reverseList(head, slow);
while(slow != nullptr && fast != nullptr){
if(slow->val != fast->val) return false;
slow = slow->next;
fast = fast->next;
}
return true;
}
};
| [
"tianhaitong@gmail.com"
] | tianhaitong@gmail.com |
656d86a9c5afe2cadd3f295a1b347d83201936d7 | c366bee80ca2fab5676688c67c8bb1af8dc5435f | /Tiket.h | 7a81d5576110c4e44d30d972bdaecf5271249322 | [] | no_license | fisnaini/Object-Oriented-Programming | 9d16b759f1d1aa7e6739b08e15ad210689f7d721 | c7e901bf19a257bcfa0eeb380fdb2588bb1dd7ee | refs/heads/main | 2023-07-10T03:32:16.028320 | 2021-08-05T12:20:24 | 2021-08-05T12:20:24 | 393,028,451 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 480 | h | #ifndef TIKET_H
#define TIKET_H
#include <string>
using namespace std;
class Tiket{
friend void cetakBarang(Tiket tiket);
private:
string kodeTiket;
string namaKereta;
string tujuan;
int hargaTiket;
int stok;
public:
Tiket(string kodeTiket, string namaKereta, string tujuan, int hargaTiket, int stok);
string getKodeTiket();
int getStok();
int getHargaTiket();
void displayDetail();
void updateStok(int jumlah);
};
#endif
| [
"noreply@github.com"
] | noreply@github.com |
1a50099cca4ceca214f959ba96ef2e4fb99d7284 | 8b9b3ce53c2612455f23419eccfe5319afee7fb9 | /Game/Game/2DSpriteComponent.h | 10033923fae1d70f7bc562ae74c783e94686be30 | [] | no_license | SeongyongShin/18_2_final | 9b2173a452cea9d59097a4587951bb6c545e3b93 | f6523fbf753a6c4985c66f844a0f5e6db4032a36 | refs/heads/master | 2020-05-26T19:50:04.577652 | 2019-05-24T04:48:07 | 2019-05-24T04:48:07 | 188,353,135 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,177 | h | #pragma once
#include "IComponent.h"
#include "directheader.h"
#include <string>
#include "CTexture.h"
using namespace std;
class C2DSpriteComponent :
public IComponent
{
private:
RenderInfo m_RenderInfo;
CTexture* m_pTexture;
CSprite* m_pSprite;
wstring m_strTextureName;
wstring m_strSpriteName;
int m_iFrame = 0;
int m_iDrawState = 0;
void SetSizeAsFrame();
public: //그릴 그림 설정
void SetTexture(wstring texture);
void SetSprite(wstring sprite);
void SetFrame(int frame);
public: //그림을 Auto K 그릴지 설정
void SetAngle(float fAngle);
void SetPos(D3DXVECTOR3 vecPos);
void SetPos(float x, float y, float z = 0);
void SetRatio(float XRatio, float YRatio);
void SetSize(float width, float height);
private:
void DrawFrame();
void DrawSprite();
void DrawTexture();
public:
virtual void Update(float deltaTime);
virtual void Render();
void SetDrawNothing() { m_iDrawState = 0; }
void SetDrawFrame() { m_iDrawState = 1; }
void SetDrawSprite() { m_iDrawState = 2; }
void SetDrawTexture() { m_iDrawState = 3; }
D3DXVECTOR3 GetTextureSize();
public:
C2DSpriteComponent();
virtual ~C2DSpriteComponent();
};
| [
"ssystarsky@naver.com"
] | ssystarsky@naver.com |
c8fd66b5400ecc449a5ddba74f0abf8a189fb9dc | ba27825e4fd7452fe42f9969adbd213008fb09fe | /Train/El_Sageer/El_Sageer_Specialist/01 - [SP]/01 - 03 - [SP]/01 - 03 - [SP] Dynamic Programming/01 - [SP] Dynamic Programming/01.onTopic/1.UVa [10130].cpp | 8fe4d5987db2e2a653d94ed6fc1e4ae13387d377 | [
"MIT"
] | permissive | mohamedGamalAbuGalala/Practice | 2e77a912ee366f633becf0f69562a068af138849 | 2a5fa3bdaf995d0c304f04231e1a69e6960f72c8 | refs/heads/master | 2022-07-18T23:25:08.717496 | 2020-05-25T07:51:40 | 2020-05-25T07:51:40 | 111,872,626 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 928 | cpp | #include <bits/stdc++.h>
using namespace std;
void fl() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("ot.txt", "w", stdout);
#else
// freopen("jumping.in", "r", stdin); // HERE
#endif
}
#define ln() printf("\n") //output new line
#define in(n) scanf("%d",&n) //scan int
#define ot(x) printf("%d", x) //output int
#define mem(a,b) memset(a,b,sizeof(a))
#define forr(i,j, n) for(int i = j;i < n;i++)
#define frr(i,j, n) for(int i = j;i >= n;i--)
////////////////////////////////////////////////////////////////////////////////////////////////
// snippet :: dinp , dhelp , dvec , lli , dfor , dcons , dbit
int main() { // dfil
fl(); //TODO
int t, n, ans, dp[33], v, w, mw, g;
in(t);
while (t--) {
in(n), ans = 0, mem(dp, 0);
forr(i,0,n and in(v) and in(w))
frr(j,30,w)
dp[j] = max(dp[j], dp[j - w] + v);
in(g);
forr(i,0,g and in(mw))
ans += dp[mw];
ot(ans), ln();
}
return 0;
}
| [
"Mohamed.abugalala@gmail.com"
] | Mohamed.abugalala@gmail.com |
0fc34efe420de233ca95b239bc4af8f5cc32488d | 6f75e3507cb1db44721157d53474be16e6304343 | /PianoFingering/VerticalCost.cpp | e2c7d973bb7f21bb1f8e809d7b5a9463c9a8ed70 | [] | no_license | BShakhovsky/PianoFingering_CalcModule | 1495b920af468cf4f6231ebbddefbabd4052c269 | 52dd07c81d8e27804cfc15be8be0714e3f9c0dcf | refs/heads/master | 2021-07-10T03:26:12.621583 | 2021-03-05T12:37:38 | 2021-03-05T12:37:38 | 45,641,793 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,980 | cpp | # include "stdafx.h"
# include "VerticalCost.h"
# include "PolyCosts.h"
using namespace std;
//#pragma warning(push)
#pragma warning(disable:5045) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
// only asserts are tested:
double VerticalCost::Calculate(const vector<pair<int16_t, char>>& notes_fingers)
{
assert("NUMBER OF NOTES IN A CHORD MUST BE BETWEEN TWO AND FIVE"
&& notes_fingers.size() >= 2 && notes_fingers.size() <= 5);
assert("NOTES SHOULD BE SORTED IN ASCENDING ORDER BEFORE CHORD COST CALCULATION"
&& is_sorted(notes_fingers.cbegin(), notes_fingers.cend(),
[](const pair<int16_t, char>& lhs, const pair<int16_t, char>& rhs)
{
return lhs.first < rhs.first;
}));
assert("ALL NOTES IN A CHORD MUST BE DIFFERENT"
&& adjacent_find(notes_fingers.cbegin(), notes_fingers.cend(),
[](const pair<int16_t, char>& lhs, const pair<int16_t, char>& rhs)
{
return lhs.first == rhs.first;
}
) == notes_fingers.cend());
auto result(PolyCosts().CostOfPair(notes_fingers.at(0), notes_fingers.at(1)));
if (notes_fingers.size() >= 3) result += PolyCosts().CostOfPair(notes_fingers.at(1), notes_fingers.at(2));
if (notes_fingers.size() >= 4) result += PolyCosts().CostOfPair(notes_fingers.at(2), notes_fingers.at(3));
if (notes_fingers.size() == 5) result += PolyCosts().CostOfPair(notes_fingers.at(3), notes_fingers.at(4));
const auto SameFinger([](const pair<int16_t, char>& lhs, const pair<int16_t, char>& rhs)
{
return lhs.second == rhs.second;
});
assert("ALL FINGERS IN A CHORD MUST BE DIFFERENT"
&& adjacent_find(notes_fingers.cbegin(), notes_fingers.cend(), SameFinger)
== notes_fingers.cend());
const auto FingersSort([](const pair<int16_t, char>& lhs, const pair<int16_t, char>& rhs)
{
return lhs.second < rhs.second;
});
const auto IsThumb([](const pair<int16_t, char>& note)
{
return 1 == note.second;
});
assert("THERE IS ONLY ONE THUMB IN A NORMAL HAND"
&& count_if(notes_fingers.cbegin(), notes_fingers.cend(), IsThumb) <= 1);
const auto thumb(find_if(notes_fingers.cbegin(), notes_fingers.cend(), IsThumb));
if (thumb != notes_fingers.cbegin() && thumb != notes_fingers.cend())
{
#ifdef _DEBUG
auto temp(notes_fingers);
const auto tempEnd(remove_if(temp.begin(), temp.end(), IsThumb));
assert("ONLY THUMB PASSING IS ALLOWED BY CURRENT ALGORITHM"
&& is_sorted(temp.begin(), tempEnd, FingersSort));
assert("ALL FINGERS IN A CHORD MUST BE DIFFERENT"
&& adjacent_find(temp.begin(), tempEnd, SameFinger) == tempEnd);
#endif
for (auto iter(notes_fingers.cbegin()); iter != thumb - 1; ++iter)
result += PolyCosts().CostOfPair(*iter, *thumb);
if (thumb != notes_fingers.cend() - 1)
result += PolyCosts().CostOfPair(*(thumb - 1), *(thumb + 1));
}
else
{
assert("ONLY THUMB PASSING IS ALLOWED BY CURRENT ALGORITHM"
&& is_sorted(notes_fingers.cbegin(), notes_fingers.cend(), FingersSort));
}
return result;
}
//#pragma warning(pop) | [
"BShakhovskey@rambler.ru"
] | BShakhovskey@rambler.ru |
87c016c598860f0e2a93637c032891d39acf62ef | c5cb356ccd642e707ba30148bee1590601f407d9 | /fast_modulo_expo.cpp | 119d8201f4d926b70de5bf8a717d7923cd88ab34 | [] | no_license | chaudhary19/CP-Algorithms-in-C_plus-plus | 90b4ae97752bc77f2df92d8c796c86c28b67532d | 0a4f7b5f6bf96bd7f92f81ce9d7b17ba27a29720 | refs/heads/master | 2023-08-29T21:04:06.424132 | 2021-10-22T06:33:58 | 2021-10-22T06:33:58 | 300,290,438 | 0 | 0 | null | 2020-10-01T13:31:57 | 2020-10-01T13:31:57 | null | UTF-8 | C++ | false | false | 387 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
ll power(ll &a,ll b);
int main()
{
ll a=123456789,b=987654321;
cout<<power(a,b); // means-> (a^b)%mod
return 0;
}
ll power(ll &a,ll b)
{
if(b==0) return 1;
ll half=power(a,b/2);
ll ret=(half*half)%mod;
if(b&1==1) ret=(ret*a)%mod;
return ret;
}
| [
"noreply@github.com"
] | noreply@github.com |
c3de699184184717eac79374bbd81e7c4727a41f | e0387cf8f45d3e2b7ea3788b299f195a621708a8 | /Source/Sable/Core/Debug/ProfNode.cpp | 982dd787c7e4939d517614531aab781bc7b18403 | [] | no_license | ClementVidal/sable.sable | eea0e822d90739269e35bed20805a2789b5fbc81 | 0ec2cd03867a4673472c1bc7b071a3f16b55fb1b | refs/heads/master | 2021-01-13T01:28:54.070144 | 2013-10-15T15:21:49 | 2013-10-15T15:21:49 | 39,085,785 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,077 | cpp | #include <Sable\Core\Debug\ProfNode.h>
#include <Sable\Core\Debug\Prof.h>
using namespace Sable;
CProfileNode::CProfileNode( ) :
m_Name( NULL ),
m_TotalCalls( 0 ),
m_TotalSamplingTime( 0 ),
m_SamplingStart( 0 ),
m_RecursionCounter( 0 ),
m_Parent( NULL ),
m_Child( NULL ),
m_Sibling( NULL )
{
Reset();
}
CProfileNode::~CProfileNode()
{
}
Float32 CProfileNode::GetTotalSamplingTime() const
{
return (Float32) ( m_TotalSamplingTime ) / CoreManager.GetDebugProf().GetTicksFreq() ;
}
CProfileNode * CProfileNode::GetChild( UInt32 index )
{
UInt32 i=0;
CProfileNode * child = m_Child;
while( child )
{
if( i == index )
return child;
i++;
child = child->GetSibling();
}
return NULL;
}
CProfileNode* CProfileNode::AddChild( String name )
{
CProfileNode * node = CoreManager.GetDebugProf().RequestNode( name, this );
node->m_Sibling = m_Child;
m_Child = node;
return node;
}
CProfileNode* CProfileNode::GetChild( String name )
{
CProfileNode * child = m_Child;
while ( child )
{
if ( child->m_Name == name )
{
return child;
}
child = child->m_Sibling;
}
return NULL;
}
Void CProfileNode::Reset()
{
m_TotalCalls = 0;
m_TotalSamplingTime = 0;
m_RecursionCounter = 0;
m_SamplingStart = 0;
CProfileNode* tmp = m_Child;
while( tmp )
{
tmp->Reset();
tmp = tmp->GetSibling();
}
m_Child = NULL;
}
Void CProfileNode::Call()
{
m_TotalCalls++;
if (m_RecursionCounter++ == 0)
{
m_SamplingStart = CoreManager.GetDebugProf().GetTicks();
}
}
Void CProfileNode::Initialize( String name, CProfileNode* parent )
{
m_Name = name;
m_Parent = parent;
m_TotalCalls = 0;
m_TotalSamplingTime = 0;
m_SamplingStart = 0;
m_RecursionCounter = 0;
m_Child = NULL;
m_Sibling = NULL;
}
bool CProfileNode::Return()
{
if ( --m_RecursionCounter == 0 && m_TotalCalls != 0 )
{
Int64 time;
time = CoreManager.GetDebugProf().GetTicks();
time-=m_SamplingStart;
m_TotalSamplingTime += time;
}
return ( m_RecursionCounter == 0 );
}
| [
"clement.vidal@lam.fr"
] | clement.vidal@lam.fr |
b69726b08dc509182f2aa8dc6c67fadf28ea1b5e | 340005a75e07c876838dbe32ad7e7e774950c257 | /Ch03_Data_Types/addition/main.cpp | fd9c9834c7b95c11394186c4ddab4074c08a4183 | [] | no_license | cnjsdfcy/SCFTGU_Caiyu | 50f832728613ca19cb36717edfdf73424471b3aa | 1b5bb764cd04d72f0f07a88d53c25a4e072f9eb1 | refs/heads/master | 2020-07-28T21:38:54.924144 | 2020-06-02T12:28:32 | 2020-06-02T12:28:32 | 209,544,794 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,281 | cpp | //FILE: main.cpp (systemc)
//# vim600:set sw=2 tw=0 fdm=marker:
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// DESCRIPTION
// This example illustrates problems with data sizes and conversions.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <iostream>
using std::cout;
using std::endl;
#include <systemc>
using namespace sc_dt;
int sc_main(int argc, char* argv[]) {
{
cout << std::string(40,'-') << endl;
int short_size = sizeof(short);
cout << "INFO: Adding 3 shorts(" << short_size << "-byte) to produce an int"<< endl;
short a = 32767;
short b = 32767;
short c = 32767;
cout << "INFO: short a = " << a << endl;
cout << "INFO: short b = " << b << endl;
cout << "INFO: short c = " << c << endl;
cout << "INFO: a + b + c = " << a + b + c << " OK" << endl;
// notice overflow
short ssum1 = a + b;
cout << "INFO: a + b = ssum1 = " << ssum1 << " OOPS" << endl;
short ssum2 = a + b + c;
cout << "INFO: a + b + c = ssum2 = " << ssum2 << " OOPS" << endl;
int csum = a + b + c;
cout << "INFO: a + b + c = csum = " << csum << " OK" << endl;
}
{
cout << std::string(40,'-') << endl;
cout << "INFO: Adding 3 sc_ints to produce a bigger sc_int" << endl;
sc_int<3> d(3);
sc_int<5> e(15);
sc_int<5> f(14);
cout << "INFO: sc_int<3> d = " << d << endl;
cout << "INFO: sc_int<5> e = " << e << endl;
cout << "INFO: sc_int<5> f = " << f << endl;
cout << "INFO: d + e + f = " << d + e + f << " OK" << endl;
// notice overflow
sc_int<5> sum1 = d + e + f;
cout << "INFO: d + e + f = sum1 = " << sum1 << " OOPS\t"
<< "Warning should jump out already" << endl;
sc_int<7> sum2 = d + e + f;
cout << "INFO: d + e + f = sum2 = " << sum2 << " OK" << endl;
}
{
cout << std::string(40,'-') << endl;
cout << "INFO: Adding 3 sc_ints to produce an sc_bigint" << endl;
sc_int<64> g("0x7000000000000000");
sc_int<64> h("0x7000000000000000");
sc_int<64> i("0x7000000000000000");
sc_bigint<70> bigsum;
cout << "INFO: sc_int<3> g = " << g << endl;
cout << "INFO: sc_int<5> h = " << h << endl;
cout << "INFO: sc_int<5> i = " << i << endl;
//notice won't promote automatically
cout << "INFO: g + h + i = " << g + h + i << " OOPS" << endl;
bigsum = g + h + i;//notice won't promote automatically
cout << "INFO: g + h + i = bigsum = " << bigsum << " OOPS" << endl;
bigsum = sc_bigint<70>(g) + h + i; //need to convert explicitly
cout << "INFO: g + h + i = bigsum = " << bigsum << " OK" << endl;
}
//
cout << std::string(40,'-') << endl;
cout << "INFO: The end" << endl;
}
//Portions COPYRIGHT (C) 2003-2004 Eklectic Ally, Inc.-------------{{{//
// Permission granted for anybody to use this example provided this //
// acknowledgement of Eklectic Ally, Inc. remains. //
//-----------------------------------------------------------------}}}//
//END $Id: main.cpp,v 1.2 2004/03/03 03:15:09 dcblack Exp $
| [
"yu.cai@montage-tech.com"
] | yu.cai@montage-tech.com |
2c3db2a72acbcef0ffb32d6fdda6c7a5797c70b5 | 9818c489717537ffd6745da059052cb0d42b124b | /c++/include/corelib/ncbi_param.hpp | ea06f29806dba6eaf922ef03bc264f9c5480e59e | [] | no_license | swuecho/igblast | 0f5bda0e9226089d952f2379bd3a01d9150913c6 | c5c06cd3e05edac0d5ac17634995472ed9e4cd7e | refs/heads/master | 2020-04-23T23:02:48.133909 | 2015-08-16T20:14:26 | 2015-08-16T20:14:26 | 40,838,293 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 24,233 | hpp | #ifndef CORELIB___NCBI_PARAM__HPP
#define CORELIB___NCBI_PARAM__HPP
/* $Id: ncbi_param.hpp 413946 2013-09-19 14:24:18Z grichenk $
* ===========================================================================
*
* PUBLIC DOMAIN NOTICE
* National Center for Biotechnology Information
*
* This software/database is a "United States Government Work" under the
* terms of the United States Copyright Act. It was written as part of
* the author's official duties as a United States Government employee and
* thus cannot be copyrighted. This software/database is freely available
* to the public for use. The National Library of Medicine and the U.S.
* Government have not placed any restriction on its use or reproduction.
*
* Although all reasonable efforts have been taken to ensure the accuracy
* and reliability of the software and data, the NLM and the U.S.
* Government do not and cannot warrant the performance or results that
* may be obtained by using this software or data. The NLM and the U.S.
* Government disclaim all warranties, express or implied, including
* warranties of performance, merchantability or fitness for any particular
* purpose.
*
* Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Authors: Eugene Vasilchenko, Aleksey Grichenko
*
* File Description:
* Parameters storage interface
*
*/
/// @file ncbiparam.hpp
/// Classes for storing parameters.
///
#include <corelib/ncbiapp.hpp>
#include <corelib/ncbithr.hpp>
/** @addtogroup Param
*
* @{
*/
BEGIN_NCBI_SCOPE
/////////////////////////////////////////////////////////////////////////////
///
/// Usage of the parameters:
///
/// - Declare the parameter with NCBI_PARAM_DECL (NCBI_PARAM_ENUM_DECL for
/// enums):
/// NCBI_PARAM_DECL(int, MySection, MyIntParam);
/// NCBI_PARAM_DECL(string, MySection, MyStrParam);
/// NCBI_PARAM_ENUM_DECL(EMyEnum, MySection, MyEnumParam);
///
/// - Add parameter definition (this will also generate static data):
/// NCBI_PARAM_DEF(int, MySection, MyIntParam, 12345);
/// NCBI_PARAM_DEF(string, MySection, MyStrParam, "Default string value");
///
/// - For enum parameters define mappings between strings and values
/// before defining the parameter:
/// NCBI_PARAM_ENUM_ARRAY(EMyEnum, MySection, MyEnumParam)
/// {
/// {"My_A", eMyEnum_A},
/// {"My_B", eMyEnum_B},
/// {"My_C", eMyEnum_C}
/// };
///
/// NCBI_PARAM_ENUM_DEF(EMyEnum, MySection, MyEnumParam, eMyEnum_B);
///
/// - Use NCBI_PARAM_TYPE() as parameter type:
/// NCBI_PARAM_TYPE(MySection, MyIntParam)::GetDefault();
/// typedef NCBI_PARAM_TYPE(MySection, MyStrParam) TMyStrParam;
/// TMyStrParam str_param; str_param.Set("Local string value");
///
/////////////////////////////////////////////////////////////////////////////
///
/// Helper functions for getting values from registry/environment
///
/// Get string configuration value.
/// NOTE: The function is not MT-safe.
///
/// @param section
/// Check application configuration named section first if not null.
/// @param variable
/// Variable name within application section.
/// If no value found in configuration file, environment variable with
/// name NCBI_CONFIG__section__variable or NCBI_CONFIG__variable will be
/// checked, depending on wether section is null.
/// @param env_var_name
/// If not empty, overrides the default NCBI_CONFIG__section__name
/// name of the environment variable.
/// @param default_value
/// If no value found neither in configuration file nor in environment,
/// this value will be returned, or empty string if this value is null.
/// @return
/// string configuration value.
/// @sa g_GetConfigInt(), g_GetConfigFlag()
string NCBI_XNCBI_EXPORT g_GetConfigString(const char* section,
const char* variable,
const char* env_var_name,
const char* default_value);
/// Get integer configuration value.
/// NOTE: The function is not MT-safe.
///
/// @param section
/// Check application configuration named section first if not null.
/// @param variable
/// Variable name within application section.
/// If no value found in configuration file, environment variable with
/// name NCBI_CONFIG__section__variable or NCBI_CONFIG__variable will be
/// checked, depending on wether section is null.
/// @param env_var_name
/// If not empty, overrides the default NCBI_CONFIG__section__name
/// name of the environment variable.
/// @param default_value
/// If no value found neither in configuration file nor in environment,
/// this value will be returned.
/// @return
/// integer configuration value.
/// @sa g_GetConfigString(), g_GetConfigFlag()
int NCBI_XNCBI_EXPORT g_GetConfigInt(const char* section,
const char* variable,
const char* env_var_name,
int default_value);
/// Get boolean configuration value.
/// NOTE: The function is not MT-safe.
///
/// @param section
/// Check application configuration named section first if not null.
/// @param variable
/// Variable name within application section.
/// If no value found in configuration file, environment variable with
/// name NCBI_CONFIG__section__variable or NCBI_CONFIG__variable will be
/// checked, depending on wether section is null.
/// @param env_var_name
/// If not empty, overrides the default NCBI_CONFIG__section__name
/// name of the environment variable.
/// @param default_value
/// If no value found neither in configuration file nor in environment,
/// this value will be returned.
/// @return
/// boolean configuration value.
/// @sa g_GetConfigString(), g_GetConfigInt()
bool NCBI_XNCBI_EXPORT g_GetConfigFlag(const char* section,
const char* variable,
const char* env_var_name,
bool default_value);
/// Get double configuration value.
/// NOTE: The function is not MT-safe.
///
/// @param section
/// Check application configuration named section first if not null.
/// @param variable
/// Variable name within application section.
/// If no value found in configuration file, environment variable with
/// name NCBI_CONFIG__section__variable or NCBI_CONFIG__variable will be
/// checked, depending on wether section is null.
/// @param env_var_name
/// If not empty, overrides the default NCBI_CONFIG__section__name
/// name of the environment variable.
/// @param default_value
/// If no value found neither in configuration file nor in environment,
/// this value will be returned.
/// @return
/// double configuration value.
/// @sa g_GetConfigString(), g_GetConfigInt()
double NCBI_XNCBI_EXPORT g_GetConfigDouble(const char* section,
const char* variable,
const char* env_var_name,
double default_value);
/////////////////////////////////////////////////////////////////////////////
///
/// Parameter declaration and definition macros
///
/// Each parameter must be declared and defined using the macros
///
// Internal definitions
#define X_NCBI_PARAM_DECLNAME(section, name) \
SNcbiParamDesc_##section##_##name
#define X_NCBI_PARAM_DECLNAME_SCOPE(scope, section, name) \
scope::SNcbiParamDesc_##section##_##name
#define X_NCBI_PARAM_ENUMNAME(section, name) \
s_EnumData_##section##_##name
// Common part of the param description structure. 'desctype' can be
// SParamDescription or SParamEnumDescription.
#define X_NCBI_PARAM_DESC_DECL(type, desctype, tagtype) \
{ \
typedef tagtype TTagType; \
typedef type TValueType; \
typedef desctype<TValueType> TDescription; \
typedef CStaticTls< type > TTls; \
static TDescription sm_ParamDescription; \
static TValueType sm_Default; \
static bool sm_DefaultInitialized; \
static TTls sm_ValueTls; \
static CParamBase::EParamState sm_State; \
}
// Common definitions related to enum parser.
// 'ptype' is the final parameter type used to make the parser unique even
// if the same enum is used by another parameter.
#define X_NCBI_PARAM_ENUM_PARSER_DECL(type, ptype) \
EMPTY_TEMPLATE inline \
CParamParser< SParamEnumDescription< type >, ptype >::TValueType \
CParamParser< SParamEnumDescription< type >, ptype >:: \
StringToValue(const string& str, \
const TParamDesc& descr) \
{ return CEnumParser< type, ptype >::StringToEnum(str, descr); } \
EMPTY_TEMPLATE inline string \
CParamParser< SParamEnumDescription< type >, ptype >:: \
ValueToString(const TValueType& val, \
const TParamDesc& descr) \
{ return CEnumParser< type, ptype >::EnumToString(val, descr); }
// Defenition of SNcbiParamDesc_XXXX static members common for normal
// and enum parameters.
#define X_NCBI_PARAM_STATIC_DEF(type, descname, defval) \
type descname::sm_Default = defval; \
bool descname::sm_DefaultInitialized = false; \
descname::TTls descname::sm_ValueTls; \
CParamBase::EParamState descname::sm_State = CParamBase::eState_NotSet \
/// Generate typename for a parameter from its {section, name} attributes
#define NCBI_PARAM_TYPE(section, name) \
CParam< X_NCBI_PARAM_DECLNAME(section, name) >
/// Parameter declaration. Generates struct for storing the parameter.
/// Section and name may be used to set default value through a
/// registry or environment variable section_name.
/// @sa NCBI_PARAM_DEF
#define NCBI_PARAM_DECL(type, section, name) \
struct X_NCBI_PARAM_DECLNAME(section, name) \
X_NCBI_PARAM_DESC_DECL(type, SParamDescription, type)
/// Same as NCBI_PARAM_DECL but with export specifier (e.g. NCBI_XNCBI_EXPORT)
/// @sa NCBI_PARAM_DECL
#define NCBI_PARAM_DECL_EXPORT(expname, type, section, name) \
struct expname X_NCBI_PARAM_DECLNAME(section, name) \
X_NCBI_PARAM_DESC_DECL(type, SParamDescription, type)
/// Enum parameter declaration. In addition to NCBI_PARAM_DECL also
/// specializes CParamParser<type, ptype> to convert between strings and
/// enum values.
/// @sa NCBI_PARAM_ENUM_ARRAY
/// @sa NCBI_PARAM_ENUM_DEF
#define NCBI_PARAM_ENUM_DECL(type, section, name) \
struct X_NCBI_PARAM_DECLNAME(section, name); \
X_NCBI_PARAM_ENUM_PARSER_DECL(type, X_NCBI_PARAM_DECLNAME(section, name)) \
struct X_NCBI_PARAM_DECLNAME(section, name) \
X_NCBI_PARAM_DESC_DECL(type, SParamEnumDescription, \
X_NCBI_PARAM_DECLNAME(section, name))
/// Same as NCBI_PARAM_ENUM_DECL but with export specifier (e.g. NCBI_XNCBI_EXPORT)
/// @sa NCBI_PARAM_ENUM_DECL
#define NCBI_PARAM_ENUM_DECL_EXPORT(expname, type, section, name) \
struct expname X_NCBI_PARAM_DECLNAME(section, name); \
X_NCBI_PARAM_ENUM_PARSER_DECL(type, X_NCBI_PARAM_DECLNAME(section, name)) \
struct expname X_NCBI_PARAM_DECLNAME(section, name) \
X_NCBI_PARAM_DESC_DECL(type, SParamEnumDescription, \
X_NCBI_PARAM_DECLNAME(section, name))
/// Parameter definition. "value" is used to set the initial parameter
/// value, which may be overriden by registry or environment.
/// @sa NCBI_PARAM_DECL
#define NCBI_PARAM_DEF(type, section, name, default_value) \
SParamDescription< type > \
X_NCBI_PARAM_DECLNAME(section, name)::sm_ParamDescription = \
{ #section, #name, 0, default_value, NULL, eParam_Default }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME(section, name), \
default_value)
/// Parameter definition. The same as NCBI_PARAM_DEF, but with a callback
/// used to initialize the default value.
/// @sa NCBI_PARAM_DEF
#define NCBI_PARAM_DEF_WITH_INIT(type, section, name, default_value, init) \
SParamDescription< type > \
X_NCBI_PARAM_DECLNAME(section, name)::sm_ParamDescription = \
{ #section, #name, 0, default_value, init, eParam_Default }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME(section, name), \
default_value)
/// Definition of a parameter with additional flags.
/// @sa NCBI_PARAM_DEF
/// @sa ENcbiParamFlags
#define NCBI_PARAM_DEF_EX(type, section, name, default_value, flags, env) \
SParamDescription< type > \
X_NCBI_PARAM_DECLNAME(section, name)::sm_ParamDescription = \
{ #section, #name, #env, default_value, NULL, flags }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME(section, name), \
default_value)
/// Definition of a parameter with additional flags and initialization
/// callback.
/// @sa NCBI_PARAM_DEF_WITH_INIT
/// @sa ENcbiParamFlags
#define NCBI_PARAM_DEF_EX_WITH_INIT(type, section, name, def_value, init, flags, env) \
SParamDescription< type > \
X_NCBI_PARAM_DECLNAME(section, name)::sm_ParamDescription = \
{ #section, #name, #env, def_value, init, flags }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME(section, name), \
def_value)
/// Similar to NCBI_PARAM_DEF except it adds "scope" (class name or
/// namespace) to the parameter's type.
/// @sa NCBI_PARAM_DECL, NCBI_PARAM_DEF
#define NCBI_PARAM_DEF_IN_SCOPE(type, section, name, default_value, scope) \
SParamDescription< type > \
X_NCBI_PARAM_DECLNAME_SCOPE(scope, section, name)::sm_ParamDescription = \
{ #section, #name, 0, default_value, NULL, eParam_Default }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME_SCOPE(scope, section, name), \
default_value)
// Static array of enum name+value pairs.
#define NCBI_PARAM_ENUM_ARRAY(type, section, name) \
static SEnumDescription< type > X_NCBI_PARAM_ENUMNAME(section, name)[] =
/// Enum parameter definition. Additional 'enums' argument should provide
/// static array of SEnumDescription<type>.
/// @sa NCBI_PARAM_ENUM_ARRAY
#define NCBI_PARAM_ENUM_DEF(type, section, name, default_value) \
SParamEnumDescription< type > \
X_NCBI_PARAM_DECLNAME(section, name)::sm_ParamDescription = \
{ #section, #name, 0, default_value, NULL, eParam_Default, \
X_NCBI_PARAM_ENUMNAME(section, name), \
ArraySize(X_NCBI_PARAM_ENUMNAME(section, name)) }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME(section, name), \
default_value)
/// Definition of an enum parameter with additional flags.
/// @sa NCBI_PARAM_ENUM_DEF
/// @sa ENcbiParamFlags
#define NCBI_PARAM_ENUM_DEF_EX(type, section, name, \
default_value, flags, env) \
SParamEnumDescription< type > \
X_NCBI_PARAM_DECLNAME(section, name)::sm_ParamDescription = \
{ #section, #name, #env, default_value, NULL, flags, \
X_NCBI_PARAM_ENUMNAME(section, name), \
ArraySize(X_NCBI_PARAM_ENUMNAME(section, name)) }; \
X_NCBI_PARAM_STATIC_DEF(type, \
X_NCBI_PARAM_DECLNAME(section, name), \
default_value)
/////////////////////////////////////////////////////////////////////////////
///
/// CParamException
///
/// Exception generated by param parser
class NCBI_XNCBI_EXPORT CParamException : public CCoreException
{
public:
enum EErrCode {
eParserError, ///< Can not convert string to value
eBadValue, ///< Unexpected parameter value
eNoThreadValue, ///< Per-thread value is prohibited by flags
eRecursion ///< Recursion while initializing param
};
/// Translate from the error code value to its string representation.
virtual const char* GetErrCodeString(void) const;
// Standard exception boilerplate code.
NCBI_EXCEPTION_DEFAULT(CParamException, CCoreException);
};
/////////////////////////////////////////////////////////////////////////////
///
/// CParamParser
///
/// Parameter parser template.
///
/// Used to read parameter value from registry/environment.
/// Default implementation requires TValue to be readable from and writable
/// to a stream. Optimized specializations exist for string and bool types.
/// The template is also specialized for each enum parameter.
///
template<class TDescription, class TParam>
class CParamParser
{
public:
typedef TDescription TParamDesc;
typedef typename TDescription::TValueType TValueType;
static TValueType StringToValue(const string& str,
const TParamDesc& descr);
static string ValueToString(const TValueType& val,
const TParamDesc& descr);
};
/////////////////////////////////////////////////////////////////////////////
///
/// CParamBase
///
/// Base class to provide single static mutex for parameters.
///
class NCBI_XNCBI_EXPORT CParamBase
{
public:
/// Current param state flag - indicates which possible sources for
/// the param have been checked. This flag does not indicate where
/// does the current value originate from (except eState_User).
/// It just shows the stage of parameter loading process.
enum EParamState {
eState_NotSet = 0, ///< The param's value has not been set yet
eState_InFunc = 1, ///< The initialization function is being executed
eState_Func = 2, ///< Initialized using FParamInit function
eState_User = 3, ///< Value has been set by user
eState_EnvVar = 4, ///< The environment variable has been checked
eState_Config = 5 ///< The app. config file has been checked
};
protected:
static SSystemMutex& s_GetLock(void);
};
/////////////////////////////////////////////////////////////////////////////
///
/// ENcbiParamFlags
///
/// CParam flags
enum ENcbiParamFlags {
eParam_Default = 0, ///< Default flags
eParam_NoLoad = 1 << 0, ///< Do not load from registry or environment
eParam_NoThread = 1 << 1 ///< Do not use per-thread values
};
typedef int TNcbiParamFlags;
/// Caching default value on construction of a param
enum EParamCacheFlag {
eParamCache_Force, ///< Force caching currently set default value.
eParamCache_Try, ///< Cache the default value if the application
///< registry is already initialized.
eParamCache_Defer ///< Do not try to cache the default value.
};
/////////////////////////////////////////////////////////////////////////////
///
/// CParam
///
/// Parameter template.
///
/// Used to store parameters with per-object values, thread-wide and
/// application-wide defaults. Global default value may be set through
/// application registry or environment.
///
/// Do not use the class directly. Create parameters through NCBI_PARAM_DECL
/// and NCBI_PARAM_DEF macros.
///
template<class TDescription>
class CParam : public CParamBase
{
public:
typedef CParam<TDescription> TParam;
typedef typename TDescription::TTagType TTagType;
typedef typename TDescription::TDescription TParamDescription;
typedef typename TParamDescription::TValueType TValueType;
typedef CParamParser<TParamDescription, TTagType> TParamParser;
typedef typename TDescription::TTls TTls;
/// Create parameter with the thread default or global default value.
/// Changing defaults does not affect the existing parameter objects.
CParam(EParamCacheFlag cache_flag = eParamCache_Try);
/// Create parameter with a given value, ignore defaults.
CParam(const TValueType& val) : m_ValueSet(true), m_Value(val) {}
/// Load parameter value from registry or environment.
/// Overrides section and name set in the parameter description.
/// Does not affect the existing default values.
CParam(const string& section, const string& name);
~CParam(void) {}
/// Get current state of the param.
static EParamState GetState(void);
/// Get current parameter value.
TValueType Get(void) const;
/// Set new parameter value (this instance only).
void Set(const TValueType& val);
/// Reset value as if it has not been initialized yet. Next call to
/// Get() will cache the thread default (or global default) value.
void Reset(void);
/// Get global default value. If not yet set, attempts to load the value
/// from application registry or environment.
static TValueType GetDefault(void);
/// Set new global default value. Does not affect values of existing
/// CParam<> objects or thread-local default values.
static void SetDefault(const TValueType& val);
/// Reload the global default value from the environment/registry
/// or reset it to the initial value specified in NCBI_PARAM_DEF.
static void ResetDefault(void);
/// Get thread-local default value if set or global default value.
static TValueType GetThreadDefault(void);
/// Set new thread-local default value.
static void SetThreadDefault(const TValueType& val);
/// Reset thread default value as if it has not been set. Unless
/// SetThreadDefault() is called, GetThreadDefault() will return
/// global default value.
static void ResetThreadDefault(void);
private:
static TValueType& sx_GetDefault(bool force_reset = false);
static TTls& sx_GetTls (void);
static EParamState& sx_GetState(void);
static bool sx_IsSetFlag(ENcbiParamFlags flag);
static bool sx_CanGetDefault(void);
mutable bool m_ValueSet;
mutable TValueType m_Value;
};
END_NCBI_SCOPE
/* @} */
#include <corelib/impl/ncbi_param_impl.hpp>
#endif /* CORELIB___NCBI_PARAM__HPP */
| [
"hwu@intellisurvey.com"
] | hwu@intellisurvey.com |
2c426ee95fae7a283318446d9e289b74c194f0a1 | 23e92ad785073701154827666c2ca7c25906b0e5 | /code/cpp/manacher.cpp | 49f813cbc02b878988c431e2f54d745c74de35c1 | [] | no_license | luqitao/choudan | bee22e338a337cef30ea0c7c9a3f8a3250f894ff | c9ff42484b2c86602e0a90b97e0a0304f159095d | refs/heads/master | 2021-01-21T02:19:55.544995 | 2015-12-05T09:24:31 | 2015-12-05T09:24:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,452 | cpp | #include<iostream>
#include<cstring>
#include<iterator>
using namespace std;
int min(int left, int right){
return left < right ? left : right;
}
int maxmanachersubstring(char *str, int len){
if(str == NULL || len <= 0)
return -1;
int newlen = 2*len + 1;
char *newstr = new char[newlen];
int i = 0;
for(i; i < len; i++){
newstr[2*i] = '#';
newstr[2*i+1] = str[i];
}
newstr[2*i] = '#';
int *record = new int[newlen];
memset(record,0,sizeof(int)*newlen);
int max = 0, id = 0;
for(i = 0; i < newlen; i++){
record[i] = max > i ? min(record[2*id - i], max - i) : 1;
while(i - record[i] >= 0 && i + record[i] < newlen &&
newstr[i+record[i]] == newstr[i-record[i]]){
++record[i];
}
if(i + record[i] > max){
max = i + record[i];
id = i;
}
}
copy(record,record+newlen,ostream_iterator<int,char>(cout," "));
cout << endl;
max = 0;
for(i = 0; i < newlen; ++i){ // the max record - 1 will the max sub manacher string
if(max < record[i]){
max = record[i];
id = i;
}
}
delete [] record;
return max - 1;
}
int main(){
char str[] = {"abcdcfcdcbcdcfc"};
//char str[] = {"abcba"};
//char str[] = {"abba"};
cout << str << endl;
cout << maxmanachersubstring(str,strlen(str)) << endl;
return 0;
}
| [
"liuanaqi@gmail.com"
] | liuanaqi@gmail.com |
7230e88eef5a8495e0f521033feea486c5bb5ac0 | 438eb7fe1e17592036161054c74f971514091aa1 | /snippets/include/labust/tools/RosbagUtilities.hpp | 1d4091bea4c50cbdbc7120e72bbc2918ad3df49e | [] | no_license | subCULTron-project/ROS-simulator | 80f49ad46c90fc2a52c4066246fe8cd7ce28b7d8 | 0c1b8675c72fb3440557477a12146c74290e4c9a | refs/heads/master | 2021-01-13T02:48:05.673770 | 2017-05-25T12:51:29 | 2017-05-25T12:51:29 | 77,134,476 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 3,301 | hpp | /*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2010, LABUST, UNIZG-FER
* 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 LABUST 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.
*********************************************************************/
#ifndef ROSBAGUTILITIES_HPP_
#define ROSBAGUTILITIES_HPP_
#include <ros/ros.h>
#include <rosbag/bag.h>
#include <rosbag/view.h>
namespace labust {
namespace tools {
class RosbagReader {
public:
RosbagReader() {}
RosbagReader(std::string bag_filename) {
bag_name = bag_filename;
}
~RosbagReader() {
bag.close();
}
void setBag(std::string bag_filename) {
bag_name = bag_filename;
}
void addTopic(std::string topic_name) {
topics.push_back(topic_name);
}
void open() {
bag.open(bag_name.c_str(), rosbag::bagmode::Read);
bag_view.addQuery(bag, rosbag::TopicQuery(topics));
message_it = bag_view.begin();
}
bool done() {
return message_it == bag_view.end();
}
template <class T>
T next() {
if (topics.size() > 1) {
ROS_ERROR("This function cannot be used with multiple topics.");
exit(1);
}
rosbag::MessageInstance m = *(message_it++);
return *(m.instantiate<T>());
}
rosbag::MessageInstance nextMessageInstance() {
return *(message_it++);
}
private:
rosbag::Bag bag;
rosbag::View bag_view;
rosbag::View::iterator message_it;
std::string bag_name;
std::vector<std::string> topics;
};
}
}
/* ROSBAGUTILITIES_HPP_ */
#endif
| [
"barbara.arbanas@fer.hr"
] | barbara.arbanas@fer.hr |
199c172926be39f1dbe8a9c4e3380f5507e83173 | 487d3da6fccadbfeb33a20cd67a31f905c628d57 | /src/dpsolver/int/ldsb/sym-imp.cpp | 3d2fe3caf48bb27087b90f9f5b2ece1092a082fa | [] | no_license | NiSE-Virginia-Tech/fzlinshu-DPSolver | 2640bb10e33373ab5aca1535f02f830536045768 | afe786d78a5eca826de1f0a171c01fed9847e608 | refs/heads/master | 2023-01-05T02:20:09.927119 | 2019-05-31T12:28:25 | 2019-05-31T12:28:25 | 305,509,889 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,579 | cpp | /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
* Main authors:
* Christopher Mears <chris.mears@monash.edu>
*
* Copyright:
* Christopher Mears, 2012
*
* This file is part of Gecode, the generic constraint
* development environment:
* http://www.gecode.org
*
* 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.
*
*/
#include <gecode/int/ldsb.hh>
#include <gecode/int/branch.hh>
namespace Gecode { namespace Int { namespace LDSB {
/// Compute symmetric literals
template <>
ArgArray<Literal>
VariableSymmetryImp<IntView>
::symmetric(Literal l, const ViewArray<IntView>& x) const {
(void) x;
if (indices.valid(l._variable) && indices.get(l._variable)) {
int n = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(indices) ; i() ; ++i)
n++;
ArgArray<Literal> lits(n);
int j = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(indices) ; i() ; ++i)
lits[j++] = Literal(i.val(), l._value);
return lits;
} else {
return ArgArray<Literal>(0);
}
}
/// Compute symmetric literals
template <>
ArgArray<Literal>
VariableSymmetryImp<BoolView>
::symmetric(Literal l, const ViewArray<BoolView>& x) const {
(void) x;
if (indices.valid(l._variable) && indices.get(l._variable)) {
int n = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(indices) ; i() ; ++i)
n++;
ArgArray<Literal> lits(n);
int j = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(indices) ; i() ; ++i)
lits[j++] = Literal(i.val(), l._value);
return lits;
} else {
return ArgArray<Literal>(0);
}
}
/// Compute symmetric literals
template <>
ArgArray<Literal>
ValueSymmetryImp<IntView>
::symmetric(Literal l, const ViewArray<IntView>& x) const {
(void) x;
if (values.valid(l._value) && values.get(l._value)) {
int n = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(values) ; i() ; ++i)
n++;
ArgArray<Literal> lits(n);
int j = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(values) ; i() ; ++i)
lits[j++] = Literal(l._variable, i.val());
return lits;
} else {
return ArgArray<Literal>(0);
}
}
/// Compute symmetric literals
template <>
ArgArray<Literal>
ValueSymmetryImp<BoolView>
::symmetric(Literal l, const ViewArray<BoolView>& x) const {
(void) x;
if (values.valid(l._value) && values.get(l._value)) {
int n = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(values) ; i() ; ++i)
n++;
ArgArray<Literal> lits(n);
int j = 0;
for (Iter::Values::BitSetOffset<Support::BitSetOffset<Space> > i(values) ; i() ; ++i)
lits[j++] = Literal(l._variable, i.val());
return lits;
} else {
return ArgArray<Literal>(0);
}
}
/// Compute symmetric literals
template <>
ArgArray<Literal>
ValueSequenceSymmetryImp<Int::IntView>
::symmetric(Literal l, const ViewArray<IntView>& x) const {
(void) x;
Support::DynamicStack<Literal, Heap> s(heap);
std::pair<int,int> location = findVar(values, n_values, seq_size, l._value);
if (location.first == -1) return dynamicStackToArgArray(s);
unsigned int seqNum = location.first;
unsigned int seqPos = location.second;
if (! dead_sequences.get(seqNum)) {
for (unsigned int seq = 0 ; seq < n_seqs ; seq++) {
if (seq == seqNum) continue;
if (dead_sequences.get(seq)) continue;
s.push(Literal(l._variable, getVal(seq,seqPos)));
}
}
return dynamicStackToArgArray(s);
}
/// Compute symmetric literals
template <>
ArgArray<Literal>
ValueSequenceSymmetryImp<BoolView>
::symmetric(Literal l, const ViewArray<BoolView>& x) const {
(void) x;
Support::DynamicStack<Literal, Heap> s(heap);
std::pair<int,int> location = findVar(values, n_values, seq_size, l._value);
if (location.first == -1) return dynamicStackToArgArray(s);
unsigned int seqNum = location.first;
unsigned int seqPos = location.second;
if (! dead_sequences.get(seqNum)) {
for (unsigned int seq = 0 ; seq < n_seqs ; seq++) {
if (seq == seqNum) continue;
if (dead_sequences.get(seq)) continue;
s.push(Literal(l._variable, getVal(seq,seqPos)));
}
}
return dynamicStackToArgArray(s);
}
}}}
// STATISTICS: int-branch
| [
"fzlinshu@pku.edu.cn"
] | fzlinshu@pku.edu.cn |
097d73d9331d0c8b1641fc48ece10508b05700a3 | 32729b7bb684a4d04867c217dd09f90804ce66e3 | /functions/events/cfgFunctions.hpp | 36d52e8e8d8bf92bd2f5eb1519d98bcac05eabfb | [] | no_license | gruppe-adler/CO_OperationFiveLions.uzbin | 982e86efe54505b7ffff466cb87e4faf53418b00 | 3a523930c35d3ba2c3ca8fdd17c8cc3867f09183 | refs/heads/main | 2023-08-17T21:14:18.027733 | 2021-09-27T14:17:49 | 2021-09-27T14:17:49 | 399,073,776 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 194 | hpp | class GRAD_events {
class events {
class addBleedoutPFH {};
class addCuratorEHs {};
class onCuratorObjectPlaced {};
class onUnitLocalityChanged {};
};
};
| [
"nomisum@gmail.com"
] | nomisum@gmail.com |
58c7c9388b0526dd4197f0af242cb8383986375c | dc2054210d903c5d629f0487e74a58e1b96958c3 | /src/rendertarget.hpp | 52594129fdea1311fa22148443b1a319c57ee186 | [
"MIT"
] | permissive | jpbruyere/vke | 57c3cdb183ec423e06aae006267e73ffd006072e | cf965d29b9092ea6b56847028dc885b67b1603e0 | refs/heads/master | 2021-07-07T08:33:13.651404 | 2018-10-26T16:59:06 | 2018-10-26T16:59:06 | 153,489,482 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,918 | hpp | #pragma once
#include "vke.hpp"
#include "texture.hpp"
namespace vke {
enum AttachmentType {ColorAttach, DepthAttach, ResolveAttach};
struct AttachmentDef {
VkImageUsageFlags usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
VkAttachmentLoadOp loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
VkAttachmentStoreOp storeOp = VK_ATTACHMENT_STORE_OP_STORE;
VkImageLayout inLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkImageLayout outLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
};
struct render_target_t {
device_t* device;
uint32_t width;
uint32_t height;
VkSampleCountFlagBits samples;
std::vector<AttachmentDef> attachmentDefs;
std::vector<vke::Texture> attachments;
int presentableAttachment = -1;
swap_chain_t* swapChain = nullptr;
VkRenderPass renderPass;
std::vector<VkFramebuffer> frameBuffers;
render_target_t(device_t* _device, VkSampleCountFlagBits _samples = VK_SAMPLE_COUNT_1_BIT);
virtual ~render_target_t();
/** @brief create default offscreen rendertarget with 1 color and 1 depth attachments */
void createDefaultOffscreenTarget (uint32_t _width, uint32_t _height, VkFormat _colorFormat, VkFormat _depthFormat);
/** @brief create default presentable rendertarget bound to a swapchain */
void createDefaultPresentableTarget (swap_chain_t* _swapChain);
void cleanupAttachments();
void createAttachments(VkFormat _colorFormat, VkFormat _depthFormat);
void createDefaultRenderPass();
void createFrameBuffers();
void updateSize();
};
}
| [
"jp_bruyere@hotmail.com"
] | jp_bruyere@hotmail.com |
ba22645d61a5a6354a499687b43d9b4879791c61 | b8740f478f99c899d1712b1aa7119b8046c0838d | /src/WalletLegacy/WalletTransactionSender.cpp | 07141165fe942fef87203ccb8de2114381d4b2b9 | [] | no_license | RavenHuginn/goldo | d486ee78a7d0be44903c3fc264366808797be6fe | a133ef578a3ceb7350160749dad781666fab18f4 | refs/heads/master | 2020-05-07T08:05:21.795058 | 2019-03-29T10:07:37 | 2019-03-29T10:07:37 | 180,308,643 | 0 | 0 | null | 2019-04-09T07:21:01 | 2019-04-09T07:21:00 | null | UTF-8 | C++ | false | false | 32,153 | cpp | // Copyright (c) 2011-2016 The Cryptonote developers
// Copyright (c) 2014-2017 XDN-project developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "crypto/crypto.h" //for rand()
#include "CryptoNoteCore/Account.h"
#include "CryptoNoteCore/CryptoNoteFormatUtils.h"
#include "CryptoNoteCore/CryptoNoteTools.h"
#include "CryptoNoteCore/TransactionApi.h"
#include "WalletLegacy/WalletTransactionSender.h"
#include "WalletLegacy/WalletUtils.h"
#include "CryptoNoteCore/CryptoNoteBasicImpl.h"
#include <Logging/LoggerGroup.h>
#include <random>
using namespace Crypto;
namespace {
using namespace CryptoNote;
uint64_t countNeededMoney(uint64_t fee, const std::vector<WalletLegacyTransfer>& transfers) {
//std::cout << "countNeededMoney = " << fee << std::endl;//z
uint64_t needed_money = fee;
for (auto& transfer: transfers) {
throwIf(transfer.amount == 0, error::ZERO_DESTINATION);
throwIf(transfer.amount < 0, error::WRONG_AMOUNT);
needed_money += transfer.amount;
throwIf(static_cast<int64_t>(needed_money) < transfer.amount, error::SUM_OVERFLOW);
}
//std::cout << "needed_money = " << needed_money << std::endl;//z
return needed_money;
}
uint64_t getSumWithOverflowCheck(uint64_t amount, uint64_t fee) {
CryptoNote::throwIf(std::numeric_limits<uint64_t>::max() - amount < fee, error::SUM_OVERFLOW);
return amount + fee;
}
void createChangeDestinations(const AccountPublicAddress& address, uint64_t neededMoney, uint64_t foundMoney, TransactionDestinationEntry& changeDts) {
if (neededMoney < foundMoney) {
changeDts.addr = address;
changeDts.amount = foundMoney - neededMoney;
}
}
void constructTx(const AccountKeys keys, const std::vector<TransactionSourceEntry>& sources, const std::vector<TransactionDestinationEntry>& splittedDests,
const std::string& extra, uint64_t unlockTimestamp, uint64_t sizeLimit, Transaction& tx, const std::vector<tx_message_entry>& messages, uint64_t ttl) {
std::vector<uint8_t> extraVec;
extraVec.reserve(extra.size());
std::for_each(extra.begin(), extra.end(), [&extraVec] (const char el) { extraVec.push_back(el);});
Logging::LoggerGroup nullLog;
bool r = constructTransaction(keys, sources, splittedDests, messages, ttl, extraVec, tx, unlockTimestamp, nullLog);
throwIf(!r, error::INTERNAL_WALLET_ERROR);
throwIf(getObjectBinarySize(tx) >= sizeLimit, error::TRANSACTION_SIZE_TOO_BIG);
}
std::unique_ptr<WalletLegacyEvent> makeCompleteEvent(WalletUserTransactionsCache& transactionCache, size_t transactionId, std::error_code ec) {
transactionCache.updateTransactionSendingState(transactionId, ec);
return std::unique_ptr<WalletSendTransactionCompletedEvent>(new WalletSendTransactionCompletedEvent(transactionId, ec));
}
std::vector<TransactionTypes::InputKeyInfo> convertSources(std::vector<TransactionSourceEntry>&& sources) {
std::vector<TransactionTypes::InputKeyInfo> inputs;
inputs.reserve(sources.size());
for (TransactionSourceEntry& source : sources) {
TransactionTypes::InputKeyInfo input;
input.amount = source.amount;
input.outputs.reserve(source.outputs.size());
for (const TransactionSourceEntry::OutputEntry& sourceOutput: source.outputs) {
TransactionTypes::GlobalOutput output;
output.outputIndex = sourceOutput.first;
output.targetKey = sourceOutput.second;
input.outputs.emplace_back(std::move(output));
}
input.realOutput.transactionPublicKey = source.realTransactionPublicKey;
input.realOutput.outputInTransaction = source.realOutputIndexInTransaction;
input.realOutput.transactionIndex = source.realOutput;
inputs.emplace_back(std::move(input));
}
return inputs;
}
std::vector<uint64_t> splitAmount(uint64_t amount, uint64_t dustThreshold) {
std::vector<uint64_t> amounts;
decompose_amount_into_digits(amount, dustThreshold,
[&](uint64_t chunk) { amounts.push_back(chunk); },
[&](uint64_t dust) { amounts.push_back(dust); } );
return amounts;
}
Transaction convertTransaction(const ITransaction& transaction, size_t upperTransactionSizeLimit) {
BinaryArray serializedTransaction = transaction.getTransactionData();
CryptoNote::throwIf(serializedTransaction.size() >= upperTransactionSizeLimit, error::TRANSACTION_SIZE_TOO_BIG);
Transaction result;
Crypto::Hash transactionHash;
Crypto::Hash transactionPrefixHash;
if (!parseAndValidateTransactionFromBinaryArray(serializedTransaction, result, transactionHash, transactionPrefixHash)) {
throw std::system_error(make_error_code(error::INTERNAL_WALLET_ERROR), "Cannot convert transaction");
}
return result;
}
uint64_t checkDepositsAndCalculateAmount(const std::vector<DepositId>& depositIds, const WalletUserTransactionsCache& transactionsCache) {
uint64_t amount = 0;
for (const auto& id: depositIds) {
Deposit deposit;
throwIf(!transactionsCache.getDeposit(id, deposit), error::DEPOSIT_DOESNOT_EXIST);
throwIf(deposit.locked, error::DEPOSIT_LOCKED);
amount += deposit.amount + deposit.interest;
}
return amount;
}
void countDepositsTotalSumAndInterestSum(const std::vector<DepositId>& depositIds, WalletUserTransactionsCache& depositsCache,
uint64_t& totalSum, uint64_t& interestsSum) {
totalSum = 0;
interestsSum = 0;
for (auto id: depositIds) {
Deposit& deposit = depositsCache.getDeposit(id);
totalSum += deposit.amount + deposit.interest;
interestsSum += deposit.interest;
}
}
} //namespace
namespace CryptoNote {
WalletTransactionSender::WalletTransactionSender(const Currency& currency, WalletUserTransactionsCache& transactionsCache, AccountKeys keys, ITransfersContainer& transfersContainer) :
m_currency(currency),
m_transactionsCache(transactionsCache),
m_isStoping(false),
m_keys(keys),
m_transferDetails(transfersContainer),
m_upperTransactionSizeLimit((m_currency.blockGrantedFullRewardZone() * 125) / 100 - m_currency.minerTxBlobReservedSize()) {}
void WalletTransactionSender::stop() {
m_isStoping = true;
}
bool WalletTransactionSender::validateDestinationAddress(const std::string& address) {
AccountPublicAddress ignore;
return m_currency.parseAccountAddressString(address, ignore);
}
void WalletTransactionSender::validateTransfersAddresses(const std::vector<WalletLegacyTransfer>& transfers) {
for (const WalletLegacyTransfer& tr : transfers) {
if (!validateDestinationAddress(tr.address)) {
throw std::system_error(make_error_code(error::BAD_ADDRESS));
}
}
}
std::unique_ptr<WalletRequest> WalletTransactionSender::makeSendRequest(TransactionId& transactionId,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events,
const std::vector<WalletLegacyTransfer>& transfers,
uint64_t fee,
const std::string& extra,
uint64_t mixIn,
uint64_t unlockTimestamp,
const std::vector<TransactionMessage>& messages,
uint64_t ttl) {
//std::cout << "WalletTransactionSender::makeSendRequest 1 = " << fee << std::endl;//z
throwIf(transfers.empty(), error::ZERO_DESTINATION);
validateTransfersAddresses(transfers);
uint64_t neededMoney = countNeededMoney(fee, transfers);
std::shared_ptr<SendTransactionContext> context = std::make_shared<SendTransactionContext>();
context->dustPolicy.dustThreshold = m_currency.defaultDustThreshold();
context->foundMoney = selectTransfersToSend(neededMoney, 0 == mixIn, context->dustPolicy.dustThreshold, context->selectedTransfers);
throwIf(context->foundMoney < neededMoney, error::WRONG_AMOUNT);
//std::cout << "WalletTransactionSender::makeSendRequest 2 = " << fee << std::endl;//z
transactionId = m_transactionsCache.addNewTransaction(neededMoney, fee, extra, transfers, unlockTimestamp, messages);
context->transactionId = transactionId;
context->mixIn = mixIn;
context->ttl = ttl;
for (const TransactionMessage& message : messages) {
AccountPublicAddress address;
bool extracted = m_currency.parseAccountAddressString(message.address, address);
if (!extracted) {
throw std::system_error(make_error_code(error::BAD_ADDRESS));
}
context->messages.push_back( { message.message, true, address } );
}
if (context->mixIn != 0) {
return makeGetRandomOutsRequest(std::move(context), false);
}
return doSendTransaction(std::move(context), events);
}
std::unique_ptr<WalletRequest> WalletTransactionSender::makeDepositRequest(TransactionId& transactionId,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events,
uint64_t term,
uint64_t amount,
uint64_t fee,
uint64_t mixIn) {
throwIf(term < m_currency.depositMinTerm(), error::DEPOSIT_TERM_TOO_SMALL);
throwIf(term > m_currency.depositMaxTerm(), error::DEPOSIT_TERM_TOO_BIG);
throwIf(amount < m_currency.depositMinAmount(), error::DEPOSIT_AMOUNT_TOO_SMALL);
uint64_t neededMoney = getSumWithOverflowCheck(amount, fee);
std::shared_ptr<SendTransactionContext> context = std::make_shared<SendTransactionContext>();
context->dustPolicy.dustThreshold = m_currency.defaultDustThreshold();
context->foundMoney = selectTransfersToSend(neededMoney, 0 == mixIn, context->dustPolicy.dustThreshold, context->selectedTransfers);
throwIf(context->foundMoney < neededMoney, error::WRONG_AMOUNT);
transactionId = m_transactionsCache.addNewTransaction(neededMoney, fee, std::string(), {}, 0, {});
context->transactionId = transactionId;
context->mixIn = mixIn;
context->depositTerm = static_cast<uint32_t>(term);
if (context->mixIn != 0) {
return makeGetRandomOutsRequest(std::move(context), true);
}
return doSendMultisigTransaction(std::move(context), events);
}
std::unique_ptr<WalletRequest> WalletTransactionSender::makeWithdrawDepositRequest(TransactionId& transactionId,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events,
const std::vector<DepositId>& depositIds,
uint64_t fee) {
std::shared_ptr<SendTransactionContext> context = std::make_shared<SendTransactionContext>();
context->dustPolicy.dustThreshold = m_currency.defaultDustThreshold();
context->foundMoney = selectDepositTransfers(depositIds, context->selectedTransfers);
throwIf(context->foundMoney < fee, error::WRONG_AMOUNT);
transactionId = m_transactionsCache.addNewTransaction(context->foundMoney, fee, std::string(), {}, 0, {});
context->transactionId = transactionId;
context->mixIn = 0;
setSpendingTransactionToDeposits(transactionId, depositIds);
return doSendDepositWithdrawTransaction(std::move(context), events, depositIds);
}
std::unique_ptr<WalletRequest> WalletTransactionSender::makeGetRandomOutsRequest(std::shared_ptr<SendTransactionContext>&& context, bool isMultisigTransaction) {
uint64_t outsCount = context->mixIn + 1;// add one to make possible (if need) to skip real output key
std::vector<uint64_t> amounts;
for (const auto& td : context->selectedTransfers) {
amounts.push_back(td.amount);
}
return std::unique_ptr<WalletRequest>(new WalletGetRandomOutsByAmountsRequest(amounts, outsCount, context,
std::bind(&WalletTransactionSender::sendTransactionRandomOutsByAmount, this, isMultisigTransaction, context,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
}
void WalletTransactionSender::sendTransactionRandomOutsByAmount(bool isMultisigTransaction,
std::shared_ptr<SendTransactionContext> context,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events,
std::unique_ptr<WalletRequest>& nextRequest,
std::error_code ec) {
if (m_isStoping) {
ec = make_error_code(error::TX_CANCELLED);
}
if (ec) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, ec));
return;
}
if (!checkIfEnoughMixins(context->outs, context->mixIn)) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::MIXIN_COUNT_TOO_BIG)));
return;
}
if (isMultisigTransaction) {
nextRequest = doSendMultisigTransaction(std::move(context), events);
} else {
nextRequest = doSendTransaction(std::move(context), events);
}
}
bool WalletTransactionSender::checkIfEnoughMixins(const std::vector<COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount>& outs, uint64_t mixIn) {
auto scanty_it = std::find_if(outs.begin(), outs.end(), [&](const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount& out) {
return out.outs.size() < mixIn;
});
return scanty_it == outs.end();
}
std::unique_ptr<WalletRequest> WalletTransactionSender::doSendTransaction(std::shared_ptr<SendTransactionContext>&& context,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events) {
if (m_isStoping) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::TX_CANCELLED)));
return std::unique_ptr<WalletRequest>();
}
try
{
WalletLegacyTransaction& transaction = m_transactionsCache.getTransaction(context->transactionId);
std::vector<TransactionSourceEntry> sources;
prepareKeyInputs(context->selectedTransfers, context->outs, sources, context->mixIn);
TransactionDestinationEntry changeDts;
changeDts.amount = 0;
uint64_t totalAmount = -transaction.totalAmount;
createChangeDestinations(m_keys.address, totalAmount, context->foundMoney, changeDts);
std::vector<TransactionDestinationEntry> splittedDests;
splitDestinations(transaction.firstTransferId, transaction.transferCount, changeDts, context->dustPolicy, splittedDests);
Transaction tx;
constructTx(m_keys, sources, splittedDests, transaction.extra, transaction.unlockTime, m_upperTransactionSizeLimit, tx, context->messages, context->ttl);
getObjectHash(tx, transaction.hash);
m_transactionsCache.updateTransaction(context->transactionId, tx, totalAmount, context->selectedTransfers);
notifyBalanceChanged(events);
return std::unique_ptr<WalletRequest>(new WalletRelayTransactionRequest(tx, std::bind(&WalletTransactionSender::relayTransactionCallback, this, context,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
}
catch(std::system_error& ec) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, ec.code()));
}
catch(std::exception&) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::INTERNAL_WALLET_ERROR)));
}
return std::unique_ptr<WalletRequest>();
}
std::unique_ptr<WalletRequest> WalletTransactionSender::doSendMultisigTransaction(std::shared_ptr<SendTransactionContext>&& context, std::deque<std::unique_ptr<WalletLegacyEvent>>& events) {
if (m_isStoping) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::TX_CANCELLED)));
return std::unique_ptr<WalletRequest>();
}
try {
//TODO decompose this method
WalletLegacyTransaction& transactionInfo = m_transactionsCache.getTransaction(context->transactionId);
std::unique_ptr<ITransaction> transaction = createTransaction();
uint64_t totalAmount = std::abs(transactionInfo.totalAmount);
std::vector<TransactionTypes::InputKeyInfo> inputs = prepareKeyInputs(context->selectedTransfers, context->outs, context->mixIn);
std::vector<uint64_t> decomposedChange = splitAmount(context->foundMoney - totalAmount, context->dustPolicy.dustThreshold);
auto depositIndex = transaction->addOutput(std::abs(transactionInfo.totalAmount) - transactionInfo.fee,
{ m_keys.address },
1,
context->depositTerm);
for (uint64_t changeOut: decomposedChange) {
transaction->addOutput(changeOut, m_keys.address);
}
transaction->setUnlockTime(transactionInfo.unlockTime);
std::vector<KeyPair> ephKeys;
ephKeys.reserve(inputs.size());
for (const auto& input: inputs) {
KeyPair ephKey;
transaction->addInput(m_keys, input, ephKey);
ephKeys.push_back(std::move(ephKey));
}
for (size_t i = 0; i < inputs.size(); ++i) {
transaction->signInputKey(i, inputs[i], ephKeys[i]);
}
transactionInfo.hash = transaction->getTransactionHash();
Deposit deposit;
deposit.amount = std::abs(transactionInfo.totalAmount) - transactionInfo.fee;
deposit.term = context->depositTerm;
deposit.creatingTransactionId = context->transactionId;
deposit.spendingTransactionId = WALLET_LEGACY_INVALID_TRANSACTION_ID;
deposit.interest = m_currency.calculateInterest(deposit.amount, deposit.term);
deposit.locked = true;
DepositId depositId = m_transactionsCache.insertDeposit(deposit, depositIndex, transaction->getTransactionHash());
transactionInfo.firstDepositId = depositId;
transactionInfo.depositCount = 1;
Transaction lowlevelTransaction = convertTransaction(*transaction, static_cast<size_t>(m_upperTransactionSizeLimit));
m_transactionsCache.updateTransaction(context->transactionId, lowlevelTransaction, totalAmount, context->selectedTransfers);
m_transactionsCache.addCreatedDeposit(depositId, deposit.amount + deposit.interest);
notifyBalanceChanged(events);
std::vector<DepositId> deposits {depositId};
return std::unique_ptr<WalletRequest>(new WalletRelayDepositTransactionRequest(lowlevelTransaction, std::bind(&WalletTransactionSender::relayDepositTransactionCallback, this, context,
deposits, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
} catch(std::system_error& ec) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, ec.code()));
} catch(std::exception&) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::INTERNAL_WALLET_ERROR)));
}
return std::unique_ptr<WalletRequest>();
}
std::unique_ptr<WalletRequest> WalletTransactionSender::doSendDepositWithdrawTransaction(std::shared_ptr<SendTransactionContext>&& context,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events, const std::vector<DepositId>& depositIds) {
if (m_isStoping) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::TX_CANCELLED)));
return std::unique_ptr<WalletRequest>();
}
try {
WalletLegacyTransaction& transactionInfo = m_transactionsCache.getTransaction(context->transactionId);
std::unique_ptr<ITransaction> transaction = createTransaction();
std::vector<MultisignatureInput> inputs = prepareMultisignatureInputs(context->selectedTransfers);
std::vector<uint64_t> outputAmounts = splitAmount(context->foundMoney - transactionInfo.fee, context->dustPolicy.dustThreshold);
for (const auto& input: inputs) {
transaction->addInput(input);
}
for (auto amount: outputAmounts) {
transaction->addOutput(amount, m_keys.address);
}
transaction->setUnlockTime(transactionInfo.unlockTime);
assert(inputs.size() == context->selectedTransfers.size());
for (size_t i = 0; i < inputs.size(); ++i) {
transaction->signInputMultisignature(i, context->selectedTransfers[i].transactionPublicKey, context->selectedTransfers[i].outputInTransaction, m_keys);
}
transactionInfo.hash = transaction->getTransactionHash();
Transaction lowlevelTransaction = convertTransaction(*transaction, static_cast<size_t>(m_upperTransactionSizeLimit));
uint64_t interestsSum;
uint64_t totalSum;
countDepositsTotalSumAndInterestSum(depositIds, m_transactionsCache, totalSum, interestsSum);
UnconfirmedSpentDepositDetails unconfirmed;
unconfirmed.depositsSum = totalSum;
unconfirmed.fee = transactionInfo.fee;
unconfirmed.transactionId = context->transactionId;
m_transactionsCache.addDepositSpendingTransaction(transaction->getTransactionHash(), unconfirmed);
return std::unique_ptr<WalletRelayDepositTransactionRequest>(new WalletRelayDepositTransactionRequest(lowlevelTransaction,
std::bind(&WalletTransactionSender::relayDepositTransactionCallback, this, context, depositIds, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
} catch(std::system_error& ec) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, ec.code()));
} catch(std::exception&) {
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, make_error_code(error::INTERNAL_WALLET_ERROR)));
}
return std::unique_ptr<WalletRequest>();
}
void WalletTransactionSender::relayTransactionCallback(std::shared_ptr<SendTransactionContext> context, std::deque<std::unique_ptr<WalletLegacyEvent>>& events,
std::unique_ptr<WalletRequest>& nextRequest, std::error_code ec) {
if (m_isStoping) {
return;
}
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, ec));
}
void WalletTransactionSender::relayDepositTransactionCallback(std::shared_ptr<SendTransactionContext> context,
std::vector<DepositId> deposits,
std::deque<std::unique_ptr<WalletLegacyEvent>>& events,
std::unique_ptr<WalletRequest>& nextRequest,
std::error_code ec) {
if (m_isStoping) {
return;
}
events.push_back(makeCompleteEvent(m_transactionsCache, context->transactionId, ec));
events.push_back(std::unique_ptr<WalletDepositsUpdatedEvent>(new WalletDepositsUpdatedEvent(std::move(deposits))));
}
void WalletTransactionSender::splitDestinations(TransferId firstTransferId, size_t transfersCount, const TransactionDestinationEntry& changeDts,
const TxDustPolicy& dustPolicy, std::vector<TransactionDestinationEntry>& splittedDests) {
uint64_t dust = 0;
digitSplitStrategy(firstTransferId, transfersCount, changeDts, dustPolicy.dustThreshold, splittedDests, dust);
throwIf(dustPolicy.dustThreshold < dust, error::INTERNAL_WALLET_ERROR);
if (0 != dust && !dustPolicy.addToFee) {
splittedDests.push_back(TransactionDestinationEntry(dust, dustPolicy.addrForDust));
}
}
void WalletTransactionSender::digitSplitStrategy(TransferId firstTransferId, size_t transfersCount,
const TransactionDestinationEntry& change_dst, uint64_t dust_threshold,
std::vector<TransactionDestinationEntry>& splitted_dsts, uint64_t& dust) {
splitted_dsts.clear();
dust = 0;
for (TransferId idx = firstTransferId; idx < firstTransferId + transfersCount; ++idx) {
WalletLegacyTransfer& de = m_transactionsCache.getTransfer(idx);
AccountPublicAddress addr;
if (!m_currency.parseAccountAddressString(de.address, addr)) {
throw std::system_error(make_error_code(error::BAD_ADDRESS));
}
decompose_amount_into_digits(de.amount, dust_threshold,
[&](uint64_t chunk) { splitted_dsts.push_back(TransactionDestinationEntry(chunk, addr)); },
[&](uint64_t a_dust) { splitted_dsts.push_back(TransactionDestinationEntry(a_dust, addr)); });
}
decompose_amount_into_digits(change_dst.amount, dust_threshold,
[&](uint64_t chunk) { splitted_dsts.push_back(TransactionDestinationEntry(chunk, change_dst.addr)); },
[&](uint64_t a_dust) { dust = a_dust; } );
}
void WalletTransactionSender::prepareKeyInputs(
const std::vector<TransactionOutputInformation>& selectedTransfers,
std::vector<COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount>& outs,
std::vector<TransactionSourceEntry>& sources, uint64_t mixIn) {
size_t i = 0;
for (const auto& td: selectedTransfers) {
assert(td.type == TransactionTypes::OutputType::Key);
sources.resize(sources.size()+1);
TransactionSourceEntry& src = sources.back();
src.amount = td.amount;
//paste mixin transaction
if(outs.size()) {
std::sort(outs[i].outs.begin(), outs[i].outs.end(),
[](const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry& a, const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry& b){return a.global_amount_index < b.global_amount_index;});
for (auto& daemon_oe: outs[i].outs) {
if(td.globalOutputIndex == daemon_oe.global_amount_index)
continue;
TransactionSourceEntry::OutputEntry oe;
oe.first = static_cast<uint32_t>(daemon_oe.global_amount_index);
oe.second = daemon_oe.out_key;
src.outputs.push_back(oe);
if(src.outputs.size() >= mixIn)
break;
}
}
//paste real transaction to the random index
auto it_to_insert = std::find_if(src.outputs.begin(), src.outputs.end(), [&](const TransactionSourceEntry::OutputEntry& a) { return a.first >= td.globalOutputIndex; });
TransactionSourceEntry::OutputEntry real_oe;
real_oe.first = td.globalOutputIndex;
real_oe.second = td.outputKey;
auto interted_it = src.outputs.insert(it_to_insert, real_oe);
src.realTransactionPublicKey = td.transactionPublicKey;
src.realOutput = interted_it - src.outputs.begin();
src.realOutputIndexInTransaction = td.outputInTransaction;
++i;
}
}
std::vector<TransactionTypes::InputKeyInfo> WalletTransactionSender::prepareKeyInputs(const std::vector<TransactionOutputInformation>& selectedTransfers,
std::vector<COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount>& outs,
uint64_t mixIn) {
std::vector<TransactionSourceEntry> sources;
prepareKeyInputs(selectedTransfers, outs, sources, mixIn);
return convertSources(std::move(sources));
}
std::vector<MultisignatureInput> WalletTransactionSender::prepareMultisignatureInputs(const std::vector<TransactionOutputInformation>& selectedTransfers) {
std::vector<MultisignatureInput> inputs;
inputs.reserve(selectedTransfers.size());
for (const auto& output: selectedTransfers) {
assert(output.type == TransactionTypes::OutputType::Multisignature);
assert(output.requiredSignatures == 1); //Other types are currently unsupported
MultisignatureInput input;
input.amount = output.amount;
input.signatureCount = output.requiredSignatures;
input.outputIndex = output.globalOutputIndex;
input.term = output.term;
inputs.emplace_back(std::move(input));
}
return inputs;
}
void WalletTransactionSender::notifyBalanceChanged(std::deque<std::unique_ptr<WalletLegacyEvent>>& events) {
uint64_t unconfirmedOutsAmount = m_transactionsCache.unconfrimedOutsAmount();
uint64_t change = unconfirmedOutsAmount - m_transactionsCache.unconfirmedTransactionsAmount();
uint64_t actualBalance = m_transferDetails.balance(ITransfersContainer::IncludeKeyUnlocked) - unconfirmedOutsAmount;
uint64_t pendingBalance = m_transferDetails.balance(ITransfersContainer::IncludeKeyNotUnlocked) + change;
events.push_back(std::unique_ptr<WalletActualBalanceUpdatedEvent>(new WalletActualBalanceUpdatedEvent(actualBalance)));
events.push_back(std::unique_ptr<WalletPendingBalanceUpdatedEvent>(new WalletPendingBalanceUpdatedEvent(pendingBalance)));
}
namespace {
template<typename URNG, typename T>
T popRandomValue(URNG& randomGenerator, std::vector<T>& vec) {
assert(!vec.empty());
if (vec.empty()) {
return T();
}
std::uniform_int_distribution<size_t> distribution(0, vec.size() - 1);
size_t idx = distribution(randomGenerator);
T res = vec[idx];
if (idx + 1 != vec.size()) {
vec[idx] = vec.back();
}
vec.resize(vec.size() - 1);
return res;
}
}
uint64_t WalletTransactionSender::selectTransfersToSend(uint64_t neededMoney, bool addDust, uint64_t dust, std::vector<TransactionOutputInformation>& selectedTransfers) {
std::vector<size_t> unusedTransfers;
std::vector<size_t> unusedDust;
//std::cout << "WalletTransactionSender::selectTransfersToSend 1 = " << neededMoney << std::endl;//z
std::vector<TransactionOutputInformation> outputs;
m_transferDetails.getOutputs(outputs, ITransfersContainer::IncludeKeyUnlocked);
for (size_t i = 0; i < outputs.size(); ++i) {
const auto& out = outputs[i];
if (!m_transactionsCache.isUsed(out)) {
if (dust < out.amount)
unusedTransfers.push_back(i);
else
unusedDust.push_back(i);
}
}
std::default_random_engine randomGenerator(Crypto::rand<std::default_random_engine::result_type>());
bool selectOneDust = addDust && !unusedDust.empty();
uint64_t foundMoney = 0;
while (foundMoney < neededMoney && (!unusedTransfers.empty() || !unusedDust.empty())) {
size_t idx;
if (selectOneDust) {
idx = popRandomValue(randomGenerator, unusedDust);
selectOneDust = false;
} else {
idx = !unusedTransfers.empty() ? popRandomValue(randomGenerator, unusedTransfers) : popRandomValue(randomGenerator, unusedDust);
}
selectedTransfers.push_back(outputs[idx]);
foundMoney += outputs[idx].amount;
}
//std::cout << "WalletTransactionSender::selectTransfersToSend 2 = " << foundMoney << std::endl;//z
return foundMoney;
}
uint64_t WalletTransactionSender::selectDepositTransfers(const std::vector<DepositId>& depositIds, std::vector<TransactionOutputInformation>& selectedTransfers) {
uint64_t foundMoney = 0;
for (auto id: depositIds) {
Hash transactionHash;
uint32_t outputInTransaction;
throwIf(m_transactionsCache.getDepositInTransactionInfo(id, transactionHash, outputInTransaction) == false, error::DEPOSIT_DOESNOT_EXIST);
{
TransactionOutputInformation transfer;
ITransfersContainer::TransferState state;
throwIf(m_transferDetails.getTransfer(transactionHash, outputInTransaction, transfer, state) == false, error::DEPOSIT_DOESNOT_EXIST);
throwIf(state != ITransfersContainer::TransferState::TransferAvailable, error::DEPOSIT_LOCKED);
selectedTransfers.push_back(std::move(transfer));
}
Deposit deposit;
bool r = m_transactionsCache.getDeposit(id, deposit);
assert(r);
foundMoney += deposit.amount + deposit.interest;
}
return foundMoney;
}
void WalletTransactionSender::setSpendingTransactionToDeposits(TransactionId transactionId, const std::vector<DepositId>& depositIds) {
for (auto id: depositIds) {
Deposit& deposit = m_transactionsCache.getDeposit(id);
deposit.spendingTransactionId = transactionId;
}
}
} /* namespace CryptoNote */
| [
"32670449+monselice@users.noreply.github.com"
] | 32670449+monselice@users.noreply.github.com |
4af4afe0041dd9785f2a81b3c6d292fa266509e0 | e9854cb02e90dab7ec0a49c65f658babba819d56 | /Curve Editor Framework/QT/src/gui/itemviews/qcolumnviewgrip.cpp | 72003846819c43b0cfeae98f31f689e247bb5d36 | [] | no_license | katzeforest/Computer-Animation | 2bbb1df374d65240ca2209b3a75a0b6a8b99ad58 | 01481111a622ae8812fb0b76550f5d66de206bab | refs/heads/master | 2021-01-23T19:46:13.455834 | 2015-06-08T21:29:02 | 2015-06-08T21:29:02 | 37,092,780 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,326 | cpp | /****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT_NO_QCOLUMNVIEW
#include "qcolumnviewgrip_p.h"
#include <qstyleoption.h>
#include <qpainter.h>
#include <qbrush.h>
#include <qevent.h>
#include <qdebug.h>
QT_BEGIN_NAMESPACE
/*
\internal
class QColumnViewGrip
QColumnViewGrip is created to go inside QAbstractScrollArea's corner.
When the mouse it moved it will resize the scroll area and emit's a signal.
*/
/*
\internal
\fn void QColumnViewGrip::gripMoved()
Signal that is emitted when the grip moves the parent widget.
*/
/*!
Creates a new QColumnViewGrip with the given \a parent to view a model.
Use setModel() to set the model.
*/
QColumnViewGrip::QColumnViewGrip(QWidget *parent)
: QWidget(*new QColumnViewGripPrivate, parent, 0)
{
#ifndef QT_NO_CURSOR
setCursor(Qt::SplitHCursor);
#endif
}
/*!
\internal
*/
QColumnViewGrip::QColumnViewGrip(QColumnViewGripPrivate & dd, QWidget *parent, Qt::WFlags f)
: QWidget(dd, parent, f)
{
}
/*!
Destroys the view.
*/
QColumnViewGrip::~QColumnViewGrip()
{
}
/*!
Attempt to resize the parent object by \a offset
returns the amount of offset that it was actually able to resized
*/
int QColumnViewGrip::moveGrip(int offset)
{
QWidget *parentWidget = (QWidget*)parent();
// first resize the parent
int oldWidth = parentWidget->width();
int newWidth = oldWidth;
if (isRightToLeft())
newWidth -= offset;
else
newWidth += offset;
newWidth = qMax(parentWidget->minimumWidth(), newWidth);
parentWidget->resize(newWidth, parentWidget->height());
// Then have the view move the widget
int realOffset = parentWidget->width() - oldWidth;
int oldX = parentWidget->x();
if (realOffset != 0)
emit gripMoved(realOffset);
if (isRightToLeft())
realOffset = -1 * (oldX - parentWidget->x());
return realOffset;
}
/*!
\reimp
*/
void QColumnViewGrip::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
QStyleOption opt;
opt.initFrom(this);
style()->drawControl(QStyle::CE_ColumnViewGrip, &opt, &painter, this);
event->accept();
}
/*!
\reimp
Resize the parent window to the sizeHint
*/
void QColumnViewGrip::mouseDoubleClickEvent(QMouseEvent *event)
{
Q_UNUSED(event);
QWidget *parentWidget = (QWidget*)parent();
int offset = parentWidget->sizeHint().width() - parentWidget->width();
if (isRightToLeft())
offset *= -1;
moveGrip(offset);
event->accept();
}
/*!
\reimp
Begin watching for mouse movements
*/
void QColumnViewGrip::mousePressEvent(QMouseEvent *event)
{
Q_D(QColumnViewGrip);
d->originalXLocation = event->globalX();
event->accept();
}
/*!
\reimp
Calculate the movement of the grip and moveGrip() and emit gripMoved
*/
void QColumnViewGrip::mouseMoveEvent(QMouseEvent *event)
{
Q_D(QColumnViewGrip);
int offset = event->globalX() - d->originalXLocation;
d->originalXLocation = moveGrip(offset) + d->originalXLocation;
event->accept();
}
/*!
\reimp
Stop watching for mouse movements
*/
void QColumnViewGrip::mouseReleaseEvent(QMouseEvent *event)
{
Q_D(QColumnViewGrip);
d->originalXLocation = -1;
event->accept();
}
/*
* private object implementation
*/
QColumnViewGripPrivate::QColumnViewGripPrivate()
: QWidgetPrivate(),
originalXLocation(-1)
{
}
QT_END_NAMESPACE
#endif // QT_NO_QCOLUMNVIEW
| [
"sonyang@seas.upenn.edu"
] | sonyang@seas.upenn.edu |
f815e4dcf81fe192e5e6d77175f4699daeb6894a | 3f7904686c4e31221ecf46d4754b4610b85dbbbd | /pepCoding/dsaFoundation/recursion-backtracking/recursion-intro/powerLogarithmic.cpp | 07a8d4fd2e9d3f819b877ff19b43edfc134b7e5e | [] | no_license | saxena11ashish/interview-prep | d013ab4b44bb1883e018a86f27b4fd4f1a8990b9 | c019bacedfc24d618239b65efe55730aee51817f | refs/heads/master | 2022-12-14T18:25:55.015988 | 2020-09-03T10:52:47 | 2020-09-03T10:52:47 | 291,242,066 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 867 | cpp | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL);
#define deb(x) cout<<"\n"<<#x<<" = "<<x<<endl;
#define deb2(x,y) cout<<"\n"<<#x<<" = "<<x<<" | "<<#y<<" = "<<y<<endl;
#define deba(a) for(int i:a)cout<<i<<" ";cout<<endl;
//----------------------------------------------------------------------//
int power(int x,int n){
if(n==0)return 1;
int nb2 = power(x,n/2);
if(n%2==0)
return nb2*nb2;
return nb2*nb2*x;
}
void func(){
int x;cin>>x;
int n;cin>>n;
cout<<power(x,n);
}
//----------------------------------------------------------------------//
int main(){
fastIO
#ifndef ONLINE_JUDGE
freopen("/home/ashish/CPP/inp.txt","r",stdin);
freopen("/home/ashish/CPP/out.txt","w",stdout);
#endif
int t=1;
// cin>>t;
while(t--){
func();
}
} | [
"ashishsxn96@gmail.com"
] | ashishsxn96@gmail.com |
abb5af6c47181974cc9aaeca8a1f72749520218b | 6bb26a4c350db4d707ca5aeb548a92b3a77fb349 | /Software/SatRot-GUI/GUI-Main/src/customlistmodel.cpp | 1c30f14e9f968cf4795db450dbb05fa00a441e7c | [
"MIT"
] | permissive | sonOFsalah-2425778/SatRot | f6da4653be1bdc0c0ef12fa6d1dfb945f66d35ea | b0be036825706404f039318bde079e3c954ed19a | refs/heads/master | 2022-04-12T22:47:22.926050 | 2020-04-12T07:40:51 | 2020-04-12T07:40:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,737 | cpp | #include "includes/customlistmodel.h"
CustomListModel::CustomListModel(QObject *parent):
QStringListModel(parent){
}
CustomListModel::CustomListModel(const QStringList &strings, QObject *parent):
QStringListModel(strings, parent){
}
Qt::ItemFlags CustomListModel::flags (const QModelIndex & index) const {
Qt::ItemFlags defaultFlags = QStringListModel::flags(index);
if (index.isValid()){
return defaultFlags | Qt::ItemIsUserCheckable;
}
return defaultFlags;
}
QVariant CustomListModel::data(const QModelIndex &index,
int role) const {
if (!index.isValid())
return QVariant();
if(role == Qt::CheckStateRole)
return checkedItems.contains(index) ?
Qt::Checked : Qt::Unchecked;
else if(role == Qt::BackgroundColorRole)
return checkedItems.contains(index) ?
QColor("#ffffb2") : QColor("#ffffff");
return QStringListModel::data(index, role);
}
bool CustomListModel::setData(const QModelIndex &index,
const QVariant &value, int role){
if(!index.isValid() || role != Qt::CheckStateRole)
return false;
if(value == Qt::Checked)
checkedItems.insert(index);
else
checkedItems.remove(index);
emit dataChanged(index, index);
return true;
}
QVariant CustomListModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
if (section == 0) {
return QString("NORAD ID");
} else if (section == 1) {
return QString("Satellite Name");
}
}
return QVariant();
}
void CustomListModel::save(){
QFile file("required_components.txt");
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
return;
QTextStream out(&file);
out << "Required components:" << "\n";
foreach(QPersistentModelIndex index, checkedItems){
QString s = index.data().toString();
const std::string z = s.toStdString();
unsigned first = z.find("[");
unsigned last = z.find("]");
const std::string str = z.substr (first+1,(last-1)-first);
QString strNew = QString::fromStdString(str);
out << strNew << "\n";
}
// QFile file("required_components.txt");
// if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
// return;
// QTextStream out(&file);
// out << "Required components:" << "\n";
// foreach(QPersistentModelIndex index, checkedItems)
// out << index.data().toString() << "\n";
}
QString CustomListModel::getNORAD(){
QString all="";
foreach(QPersistentModelIndex index, checkedItems){
QString s = index.data().toString();
const std::string z = s.toStdString();
unsigned first = z.find("[");
unsigned last = z.find("]");
const std::string str = z.substr (first+1,(last-1)-first);
QString strNew = QString::fromStdString(str);
all += strNew + ",";
}
//remove last ',' in the QString
const std::string y = all.toStdString();
const std::string w = y.substr(0, y.size()-1);
all = QString::fromStdString(w);
return all;
}
QList<QString> CustomListModel::getNORADObj(){
QList<QString> all;
foreach(QPersistentModelIndex index, checkedItems){
QString s = index.data().toString();
const std::string z = s.toStdString();
unsigned first = z.find("[");
unsigned last = z.find("]");
const std::string str = z.substr (first+1,(last-1)-first);
QString strNew = QString::fromStdString(str);
all.append(strNew);
}
return all;
}
| [
"ahmad.muhd13@hotmail.com"
] | ahmad.muhd13@hotmail.com |
5494e01c77a9d48b66ab67bbed5deeafa107e360 | 66b01f14834688d9bc3bd735738b15aecd28ce8f | /Genetic/main/src/GeneticGeneFormulaOperand.cpp | edf2f31fa7fe8e9c472c76e8be7faee82d7d172a | [] | no_license | fenardC/AI_geneticCarsCPP | 14d1146cc97a4a55560d0a3ab0054f6d7a510300 | f07fcffdcf2dc4311a710c7642bda5a5e50bac3f | refs/heads/master | 2020-03-16T18:50:49.282700 | 2019-01-13T12:29:22 | 2019-01-13T12:39:06 | 132,889,148 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,119 | cpp | #include "Debug/main/inc/Logger.hpp"
#include "Genetic/main/inc/GeneticGeneFormulaOperand.hpp"
#include "Genetic/main/inc/GeneticGeneTreeBranch.hpp"
#include "Misc/main/inc/Misc.hpp"
static std::vector<CObject *> _dummy;
std::vector<CObject *> & dummy = _dummy;
GeneticGeneFormulaOperand::GeneticGeneFormulaOperand()
: GeneticGeneTreeBranch(dummy) {
Logger::trace(std::string("GeneticGeneFormulaOperand::GeneticGeneFormulaOperand()>"));
for (auto & ope : mapNbOperand) {
Logger::trace(ope.first.toString() + std::string(" : ") + ope.second.toString() + std::string(" "));
}
}
GeneticGeneFormulaOperand::~GeneticGeneFormulaOperand() {
Logger::trace(std::string("GeneticGeneFormulaOperand::~GeneticGeneFormulaOperand()<"));
}
void GeneticGeneFormulaOperand::addOperator(CString ope, CInteger nbOperand) {
listOperatorPossible.push_back(ope);
mapNbOperand[ope] = nbOperand;
}
void GeneticGeneFormulaOperand::addOperand(CInteger operand) {
listOperandPossible.push_back(operand);
}
GeneticGeneFormulaOperand * GeneticGeneFormulaOperand::clone() { /*const*/
GeneticGeneFormulaOperand * geneFormulaOperand = new GeneticGeneFormulaOperand();
for (auto c : code) {
geneFormulaOperand->code.push_back(c);
}
for (auto branch : listBranch) {
GeneticGeneTreeBranch * op2 = branch->clone();
op2->setParent(geneFormulaOperand);
geneFormulaOperand->listBranch.push_back(op2);
}
return geneFormulaOperand;
}
bool GeneticGeneFormulaOperand::equals(const GeneticGene & /*other*/) const {
Logger::error(std::string("GeneticGeneFormulaOperand::equals(): returning false in all cases"));
return false;
}
CInteger GeneticGeneFormulaOperand::getNbOperandForOperator(CString ope) {
return mapNbOperand[ope];
}
bool GeneticGeneFormulaOperand::isOperator() const {
bool result = false;
if (code.size() > 0) {
const auto search = std::find(listOperatorPossible.begin(), listOperatorPossible.end(), *code[0]);
if (search != listOperatorPossible.end()) {
result = true;
}
}
return result;
}
void GeneticGeneFormulaOperand::mutate() {
GeneticGeneTreeBranch::mutate();
repareGene();
}
GeneticGeneFormulaOperand * GeneticGeneFormulaOperand::randomGene() {
Logger::trace(std::string("GeneticGeneFormulaOperand::randomGene()>"));
code.clear();
if (Misc::random(50)) {
code.push_back(&listOperatorPossible[Misc::random(0, listOperatorPossible.size() - 1)]);
}
else {
code.push_back(&listOperandPossible[Misc::random(0, listOperandPossible.size() - 1)]);
}
repareGene();
return this;
}
void GeneticGeneFormulaOperand::repareGene() {
std::vector<GeneticGeneTreeBranch *> listOld = listBranch;
#warning TO BE DONE
#if 0
if (isOperator()) {
int nb = getNbOperandForOperator(code[0]) - listBranch.size();
if (nb > 0) {
for (int i = 0 ; i < nb ; i++) {
GeneticGeneFormulaOperand * p = new GeneticGeneFormulaOperand();
listBranch.push_back(p->randomGene());
}
}
else {
for (int i = 0 ; i < -nb ; i++) {
listBranch.erase(listBranch.begin() + Misc::random(0, listBranch.size() - 1));
}
}
}
else {
listBranch.clear();
}
#endif
for (auto gene : listOld) {
gene->setParent(nullptr);
}
for (auto gene : listBranch) {
gene->setParent(this);
}
}
std::vector<CInteger> GeneticGeneFormulaOperand::listOperandPossible = {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
};
std::vector<CString> GeneticGeneFormulaOperand::listOperatorPossible = {
std::string("+"),
std::string("-"),
std::string("*"),
std::string("/"),
std::string("sqrt"),
std::string("^2")
};
std::map<CString, CInteger, CString::Compare> GeneticGeneFormulaOperand::mapNbOperand = {
{std::string("+"), 2},
{std::string("-"), 2},
{std::string("*"), 2},
{std::string("/"), 2},
{std::string("sqrt"), 1},
{std::string("^2"), 1}
};
| [
"38584896+fenardC@users.noreply.github.com"
] | 38584896+fenardC@users.noreply.github.com |
8098c4eb407001b81e3baa50dd9f9752efc0e65a | 6b770c1e760da91325b0288c56cdcc57c8405182 | /14. Exams/2020.02.29/04. Starcraft III/BattleCruser.cpp | 1f9ef7fa094a7ca2af9cdd7fa9b1f94641a91351 | [] | no_license | Martin-BG/SoftUni-CPP-Advanced | 5c4ef936fdac3abbe25c608a6bbf2a63725af9da | 5b5f6112c88da0fa05d40eef4dc0db7235426866 | refs/heads/master | 2023-01-12T10:34:56.200137 | 2022-12-24T13:19:24 | 2022-12-24T13:19:24 | 147,219,252 | 0 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 728 | cpp | #include "BattleCruser.h"
#include "ConsolePrinter.h"
BattleCruser::BattleCruser(const AirShipType type,
const int health,
const int damage,
const int shipId) :
TerranAirShip(type, health, damage, shipId) { }
void BattleCruser::dealDamage(std::vector<std::unique_ptr<AirShip>>& enemyFleet) {
if (enemyFleet.empty()) {
return;
}
auto& enemyAirShip = enemyFleet.back();
int damage = (_passedTurns % 5 == YAMATO_CANNON_LOADING_TIME) ?
_damage * 5 : _damage;
enemyAirShip->takeDamage(damage);
if (!enemyAirShip->isAlive()) {
printKill(*this, enemyAirShip->getAirShipId());
enemyFleet.pop_back();
}
}
| [
"MartinBG@abv.bg"
] | MartinBG@abv.bg |
2e7de6db0538396dfb2fc3d5d2559a3739a3dea8 | d7903c07410d46babbffea4adebf702a6e4aaff5 | /src/dirichlet/task_generator/src/main.cpp | dbe323387b8d62f43f10727df034dadf553c6d8e | [] | no_license | Kotevode/Purple | 949a43fe1a6139bdc5fe50e51a9e5c5b5c84bbd8 | 6c41e7a380289dfabec4602cf7d9759e5d156c57 | refs/heads/dirichlet_solver | 2021-01-20T01:12:23.142293 | 2017-05-04T19:52:01 | 2017-05-04T19:52:01 | 89,236,342 | 0 | 0 | null | 2017-06-09T19:13:58 | 2017-04-24T12:14:42 | C++ | UTF-8 | C++ | false | false | 1,503 | cpp | //
// Created by Mark on 23.04.17.
//
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include "MeshGenerator.h"
#include "config.h"
#include "TaskGenerator.h"
using namespace std;
int main(int argc, char *argv[]) {
int size = 10000;
int count = 50;
if (argc > 1)
size = atoi(argv[1]);
if (argc > 2)
count = atoi(argv[2]);
cout << size << "\t" << size << endl;
// Generating u-u
auto generator = new MeshGenerator(
X0, Y0, XN, YN, size
);
double *u = generator->generate_u([](double x, double y) -> double {
if (x == X0)
return F_X0(y);
else if (x == XN)
return F_XN(y);
else if (y == Y0)
return F_Y0(x);
else if (y == YN)
return F_YN(x);
else return 0;
});
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++)
cout << u[i * size + j] << "\t";
cout << endl;
}
// Generating f-u
double *f = generator->generate_f([](double x, double y) -> double {
return F(x, y);
});
for(int i = 0; i < size; i++){
for( int j = 0; j < size; j++)
cout << f[i * size + j] << "\t";
cout << endl;
}
// Generating tasks
auto tasks = TaskGenerator::generate(count, size);
cout << tasks.size() << endl;
for_each(tasks.begin(), tasks.end(), [](auto &t) {
cout << t << endl;
});
free(u);
free(f);
return 0;
}
| [
"kotevode@icloud.com"
] | kotevode@icloud.com |
d167f960ca90618680a6ce168978ca40c06344d2 | 883887c3c84bd3ac4a11ac76414129137a1b643b | /DesktopMan/Protocol/FrameOut.cpp | 328157fd66982e23eda21f7fd2c87282ccae3e0a | [] | no_license | 15831944/vAcademia | 4dbb36d9d772041e2716506602a602d516e77c1f | 447f9a93defb493ab3b6f6c83cbceb623a770c5c | refs/heads/master | 2022-03-01T05:28:24.639195 | 2016-08-18T12:32:22 | 2016-08-18T12:32:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,788 | cpp | #include "stdafx.h"
#include "FrameOut.h"
#include "vase.h"
#include "vasebitmap.h"
#include "VASEFramesDifPack.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
using namespace SharingManProtocol;
CFrameOut::CFrameOut(unsigned short sessionID, unsigned int aTime, VASEFramesDifPack* pack, bool abKeyFrame, bool useNewCodec)
{
GetDataBuffer().reset();
GetDataBuffer().add<unsigned short>( sessionID);
byte keyFrameFlag = abKeyFrame ? 1 : 0;
GetDataBuffer().add<byte>( useNewCodec);
GetDataBuffer().add<byte>( keyFrameFlag);
if( keyFrameFlag)
{
ATLASSERT( pack->GetBitmapsCount() == 1);
unsigned short keyFrameWidth = 0;
unsigned short keyFrameHeight = 0;
if( pack->GetBitmapsCount() > 0)
{
VASEBitmap* bitmap = pack->GetBitmap(0);
ATLASSERT( bitmap);
keyFrameWidth = (unsigned short)bitmap->GetSize().cx;
keyFrameHeight = (unsigned short)bitmap->GetSize().cy;
}
GetDataBuffer().add<unsigned short>(keyFrameWidth);
GetDataBuffer().add<unsigned short>(keyFrameHeight);
}
GetDataBuffer().add<unsigned int>( aTime);
GetDataBuffer().add<unsigned int>( pack->GetBitmapsCount());
for (unsigned int i=0; i<pack->GetBitmapsCount(); i++)
{
VASEBitmap* bitmap = pack->GetBitmap(i);
GetDataBuffer().add<unsigned short>((unsigned short)bitmap->GetPosition().x);
GetDataBuffer().add<unsigned short>((unsigned short)bitmap->GetPosition().y);
GetDataBuffer().add<unsigned int>((unsigned int)bitmap->GetSize().cx);
GetDataBuffer().add<unsigned int>((unsigned int)bitmap->GetSize().cy);
const void* bitmapData = NULL;
unsigned int dataSize = 0;
bitmap->GetBuffer( &bitmapData, &dataSize);
GetDataBuffer().add<unsigned int>( dataSize);
GetDataBuffer().addData( bitmapData, dataSize);
}
}
| [
"ooo.vspaces@gmail.com"
] | ooo.vspaces@gmail.com |
af2343924788941369753b825215bc46028196f8 | f7c21624103462928c9816df4d2b0b97f28fb439 | /mohe-sx-game-server/MJShanxi2/LogicManager/SpecActive.h | 46295afb3268258f2a69abaf4e06df5fd1d35f62 | [] | no_license | Pircs/lipengServer | 17e1fc7595e8e55e5b2b7e5f582be062e7713f40 | 1e7c13338eee6398e5ada73d31845aecd9d920d8 | refs/heads/master | 2020-09-18T10:33:08.268173 | 2019-10-07T11:13:00 | 2019-10-07T11:13:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,425 | h | #pragma once
#ifndef _SPEC_ACTIVE_H
#define _SPEC_ACTIVE_H
#include "LSingleton.h"
#include "LMsgS2S.h"
class SpecActive : public LSingleton<SpecActive>
{
public:
SpecActive();
~SpecActive();
virtual bool Init();
virtual bool Final();
void addSpecActive(const LMsgLMG2LSpecActive* specList);
void sendToLogic(Lint logicId,Lint id = 0); //id=0，全部发， id !=0 ,发指定id的
void sendToAllLogic(Lint id = 0); //id=0，全部发， id !=0 ,发指定id的
private:
std::map<Lint, boost::shared_ptr<SpecActiveItem>> m_mapId2SpecActive;
void addSpecActiveItem(boost::shared_ptr<SpecActiveItem> specItem); //添加和更新，存在更新，不存在更新
//////////////////////////////////////////////////////////////////////////////////////
//特殊牌型
Lstring getMessage(Lint userId, Lstring nike, Lint time, std::vector<Lint> paixing);
private:
void Init_paixing();
std::map<Lint, Lstring> m_mapId2PaiXing;
std::vector<Lint> m_paiXingNo{ 1003,1006,1005,1004,1007,1027,1028,1030,1029 };
std::vector<Lstring> m_paiXingName{ " 七小对 "," 一条龙 "," 清一色 "," 豪华七小对 "," 十三幺 "," 青龙 "," 清七对 "," 清豪华七小对","字一色 " };
//////////////////////////////////////////////////////////////////////////////////////
};
#define gSpecActive SpecActive::Instance()
#endif
| [
"lipeng404673101@163.com"
] | lipeng404673101@163.com |
488a8f74f12a3429de87281d9c6ce085729e54c1 | 5a3803bc1b8ac0b0ac1db09e4186454b0e3a896f | /SingleTop/src/SingleTopSystematicsTreesDumper.cc | 62e1b8b06b5c024aefc32445bf89bfedca5a81d9 | [] | no_license | oiorio/TopQuarkAnalysis | 07320ac36e33fd047e8297ce7c8ff3cb76f98c8f | 8833ec7423e8ad52ad1883a584958501221bacc4 | refs/heads/master | 2021-01-16T21:31:17.986023 | 2013-09-20T13:53:48 | 2013-09-20T13:53:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 222,830 | cc | /*
*\Author: O.Iorio
*
*
*
*\version $Id: SingleTopSystematicsTreesDumper.cc,v 1.12.2.18.2.16.2.6 2013/06/21 20:40:25 oiorio Exp $
*/
// This analyzer dumps the histograms for all systematics listed in the cfg file
//
//
//
#define DEBUG 0 // 0=false
#define MC_DEBUG 0 // 0=false else -> dont process preselection
#define C_DEBUG 0 // currently debuging
#include "TopQuarkAnalysis/SingleTop/interface/SingleTopSystematicsTreesDumper.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Common/interface/TriggerNames.h"
//#include "PhysicsTools/UtilAlgos/interface/TFileService.h"
#include "CommonTools/UtilAlgos/interface/TFileService.h"
//#include "FWCore/Framework/interface/TriggerNames.h"
#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
#include "DataFormats/Candidate/interface/NamedCompositeCandidate.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include <Math/VectorUtil.h>
//#include "CommonTools/CandUtils/interface/Booster.h"
#include <sstream> //libreria per usare stringstream
//#include "PhysicsTools/Utilities/interface/LumiReWeighting.h"
#include "DataFormats/Math/interface/deltaR.h"
#include "CondFormats/JetMETObjects/interface/JetCorrectionUncertainty.h"
#include "TopQuarkAnalysis/SingleTop/interface/EquationSolver.h"
namespace LHAPDF
{
void initPDFSet(int nset, const std::string &filename, int member = 0);
int numberPDF(int nset);
void usePDFMember(int nset, int member);
double xfx(int nset, double x, double Q, int fl);
double getXmin(int nset, int member);
double getXmax(int nset, int member);
double getQ2min(int nset, int member);
double getQ2max(int nset, int member);
void extrapolate(bool extrapolate = true);
}
SingleTopSystematicsTreesDumper::SingleTopSystematicsTreesDumper(const edm::ParameterSet &iConfig)
{
//MCLightQuarkProducer = iConfig.getParameter<InputTag>("MCLightQuarkProducer");
systematics = iConfig.getUntrackedParameter<std::vector<std::string> >("systematics");
rate_systematics = iConfig.getUntrackedParameter<std::vector<std::string> >("rateSystematics");
//Channel information
channelInfo = iConfig.getParameter<edm::ParameterSet>("channelInfo");
//Cross section, name and number of events
channel = channelInfo.getUntrackedParameter<string>("channel");
crossSection = channelInfo.getUntrackedParameter<double>("crossSection");
originalEvents = channelInfo.getUntrackedParameter<double>("originalEvents");
finalLumi = channelInfo.getUntrackedParameter<double>("finalLumi");
MTWCut = channelInfo.getUntrackedParameter<double>("MTWCut", 50);
RelIsoCut = channelInfo.getUntrackedParameter<double>("RelIsoCut", 0.1);
loosePtCut = channelInfo.getUntrackedParameter<double>("loosePtCut", 40);
addPDFToNJets = channelInfo.getUntrackedParameter< bool >("addPDFToNJets", false);
isSingleTopCompHEP_ = channelInfo.getUntrackedParameter< bool >("isSingleTopCompHEP", false);
maxPtCut = iConfig.getUntrackedParameter<double>("maxPtCut", 40);
//tight leptons
leptonsFlavour_ = iConfig.getUntrackedParameter< std::string >("leptonsFlavour");
leptonsPt_ = iConfig.getParameter< edm::InputTag >("leptonsPt");
leptonsPhi_ = iConfig.getParameter< edm::InputTag >("leptonsPhi");
leptonsEta_ = iConfig.getParameter< edm::InputTag >("leptonsEta");
leptonsEnergy_ = iConfig.getParameter< edm::InputTag >("leptonsEnergy");
leptonsCharge_ = iConfig.getParameter< edm::InputTag >("leptonsCharge");
leptonsDeltaCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("leptonsDeltaCorrectedRelIso");
leptonsRhoCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("leptonsRhoCorrectedRelIso");
leptonsDB_ = iConfig.getParameter< edm::InputTag >("leptonsDB");
leptonsDZ_ = iConfig.getParameter< edm::InputTag >("leptonsDZ");
leptonsID_ = iConfig.getParameter< edm::InputTag >("leptonsID");
leptonsMVAID_ = iConfig.getParameter< edm::InputTag >("leptonsMVAID");
leptonsNHits_ = iConfig.getParameter< edm::InputTag >("leptonsNHits");
//qcd leptons
qcdLeptonsPt_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsPt");
qcdLeptonsPhi_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsPhi");
qcdLeptonsEta_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsEta");
qcdLeptonsEnergy_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsEnergy");
qcdLeptonsCharge_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsCharge");
qcdLeptonsDeltaCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsDeltaCorrectedRelIso");
qcdLeptonsRhoCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsRhoCorrectedRelIso");
qcdLeptonsDB_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsDB");
qcdLeptonsID_ = iConfig.getParameter< edm::InputTag >("qcdLeptonsID");
leptonsFlavour_ = iConfig.getUntrackedParameter< std::string >("leptonsFlavour");
looseMuonsDeltaCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("looseMuonsDeltaCorrectedRelIso");
looseMuonsRhoCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("looseMuonsRhoCorrectedRelIso");
looseElectronsDeltaCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("looseElectronsDeltaCorrectedRelIso");
looseElectronsRhoCorrectedRelIso_ = iConfig.getParameter< edm::InputTag >("looseElectronsRhoCorrectedRelIso");
//Jets
jetsEta_ = iConfig.getParameter< edm::InputTag >("jetsEta");
jetsPt_ = iConfig.getParameter< edm::InputTag >("jetsPt");
jetsPhi_ = iConfig.getParameter< edm::InputTag >("jetsPhi");
jetsEnergy_ = iConfig.getParameter< edm::InputTag >("jetsEnergy");
allJetsPt_ = iConfig.getParameter< edm::InputTag >("allJetsPt");
allJetsPhi_ = iConfig.getParameter< edm::InputTag >("allJetsPhi");
allJetsEta_ = iConfig.getParameter< edm::InputTag >("allJetsEta");
allJetsFlavour_ = iConfig.getParameter< edm::InputTag >("allJetsFlavour");
jetsBTagAlgo_ = iConfig.getParameter< edm::InputTag >("jetsBTagAlgo");
jetsAntiBTagAlgo_ = iConfig.getParameter< edm::InputTag >("jetsAntiBTagAlgo");
jetsPileUpID_ = iConfig.getParameter< edm::InputTag >("jetsPileUpDiscr");
jetsPileUpWP_ = iConfig.getParameter< edm::InputTag >("jetsPileUpWP");
jetsBeta_ = iConfig.getParameter< edm::InputTag >("jetsBeta");
jetsDZ_ = iConfig.getParameter< edm::InputTag >("jetsDZ");
jetsRMS_ = iConfig.getParameter< edm::InputTag >("jetsRMS");
jetsFlavour_ = iConfig.getParameter< edm::InputTag >("jetsFlavour");
genJetsPt_ = iConfig.getParameter< edm::InputTag >("genJetsPt");
genJetsEta_ = iConfig.getParameter< edm::InputTag >("genJetsEta");
genAllJetsPt_ = iConfig.getParameter< edm::InputTag >("genAllJetsPt");
genAllJetsEta_ = iConfig.getParameter< edm::InputTag >("genAllJetsEta");
METPhi_ = iConfig.getParameter< edm::InputTag >("METPhi");
METPt_ = iConfig.getParameter< edm::InputTag >("METPt");
UnclMETPx_ = iConfig.getParameter< edm::InputTag >("UnclusteredMETPx");
UnclMETPy_ = iConfig.getParameter< edm::InputTag >("UnclusteredMETPy");
jetsCorrTotal_ = iConfig.getParameter< edm::InputTag >("jetsCorrTotal");
doBScan_ = iConfig.getUntrackedParameter< bool >("doBScan", false);
doQCD_ = iConfig.getUntrackedParameter< bool >("doQCD", true);
doPDF_ = iConfig.getUntrackedParameter< bool >("doPDF", true);
doBTagSF_ = iConfig.getUntrackedParameter< bool >("doBTagSF", true);
useMVAID_ = iConfig.getUntrackedParameter< bool >("useMVAID", false);
useCutBasedID_ = iConfig.getUntrackedParameter< bool >("useCutBasedID", true);
cout << " mva id " << useMVAID_ << " cutbased " << useCutBasedID_ << endl;
if(useCutBasedID_ == useMVAID_){
cout << " can't use cutBasedID and MVAID together! Choose one!"<<endl;
}
//Q2 part
x1_ = iConfig.getParameter<edm::InputTag>("x1") ;
x2_ = iConfig.getParameter<edm::InputTag>("x2") ;
id1_ = iConfig.getParameter<edm::InputTag>("id1") ;
id2_ = iConfig.getParameter<edm::InputTag>("id2") ;
scalePDF_ = iConfig.getParameter<edm::InputTag>("scalePDF") ;
//Pile Up Part
np1_ = iConfig.getParameter< edm::InputTag >("nVerticesPlus");//,"PileUpSync");
nm1_ = iConfig.getParameter< edm::InputTag >("nVerticesMinus");//,"PileUpSync");
n0_ = iConfig.getParameter< edm::InputTag >("nVertices");//,"PileUpSync");
vertexZ_ = iConfig.getParameter< edm::InputTag >("vertexZ");//,"PileUpSync");
doPU_ = iConfig.getUntrackedParameter< bool >("doPU", false);
doResol_ = iConfig.getUntrackedParameter< bool >("doResol", false);
doTurnOn_ = iConfig.getUntrackedParameter< bool >("doTurnOn", true);
doReCorrection_ = iConfig.getUntrackedParameter< bool >("doReCorrection", false);
dataPUFile_ = channelInfo.getUntrackedParameter< std::string >("Season", "SummerMean11");
takeBTagSFFromDB_ = iConfig.getUntrackedParameter< bool >("takeBTagSFFromDB", true);
doJetTrees_ = iConfig.getUntrackedParameter< bool >("doJetTrees", true);
algo_ = iConfig.getUntrackedParameter< std::string >("algo", "CSVT");
doLooseBJetVeto_ = iConfig.getUntrackedParameter< bool >("doLooseBJetVeto", false);
//MC Truth part
doMCTruth_ = iConfig.getUntrackedParameter< bool >("doMCTruth", false);
doFullMCTruth_ = iConfig.getUntrackedParameter< bool >("doFullMCTruth", false);
//Quarks/leptons
MCQuarksEta_ = iConfig.getParameter< edm::InputTag >("MCQuarksEta");
MCQuarksPt_ = iConfig.getParameter< edm::InputTag >("MCQuarksPt");
MCQuarksPhi_ = iConfig.getParameter< edm::InputTag >("MCQuarksPhi");
MCQuarksEnergy_ = iConfig.getParameter< edm::InputTag >("MCQuarksEnergy");
MCQuarksPdgId_ = iConfig.getParameter< edm::InputTag >("MCQuarksPdgId");
MCQuarksMotherId_ = iConfig.getParameter< edm::InputTag >("MCQuarksMotherId");
MCBQuarksEta_ = iConfig.getParameter< edm::InputTag >("MCBQuarksEta");
MCBQuarksPt_ = iConfig.getParameter< edm::InputTag >("MCBQuarksPt");
MCBQuarksPhi_ = iConfig.getParameter< edm::InputTag >("MCBQuarksPhi");
MCBQuarksEnergy_ = iConfig.getParameter< edm::InputTag >("MCBQuarksEnergy");
MCBQuarksPdgId_ = iConfig.getParameter< edm::InputTag >("MCBQuarksPdgId");
MCBQuarksMotherId_ = iConfig.getParameter< edm::InputTag >("MCBQuarksMotherId");
MCLeptonsEta_ = iConfig.getParameter< edm::InputTag >("MCLeptonsEta");
MCLeptonsPt_ = iConfig.getParameter< edm::InputTag >("MCLeptonsPt");
MCLeptonsPhi_ = iConfig.getParameter< edm::InputTag >("MCLeptonsPhi");
MCLeptonsEnergy_ = iConfig.getParameter< edm::InputTag >("MCLeptonsEnergy");
MCLeptonsPdgId_ = iConfig.getParameter< edm::InputTag >("MCLeptonsPdgId");
MCLeptonsMotherId_ = iConfig.getParameter< edm::InputTag >("MCLeptonsMotherId");
MCNeutrinosEta_ = iConfig.getParameter< edm::InputTag >("MCNeutrinosEta");
MCNeutrinosPt_ = iConfig.getParameter< edm::InputTag >("MCNeutrinosPt");
MCNeutrinosPhi_ = iConfig.getParameter< edm::InputTag >("MCNeutrinosPhi");
MCNeutrinosEnergy_ = iConfig.getParameter< edm::InputTag >("MCNeutrinosEnergy");
MCNeutrinosPdgId_ = iConfig.getParameter< edm::InputTag >("MCNeutrinosPdgId");
MCNeutrinosMotherId_ = iConfig.getParameter< edm::InputTag >("MCNeutrinosMotherId");
//Top
MCTopsEta_ = iConfig.getParameter< edm::InputTag >("MCTopsEta");
MCTopsPt_ = iConfig.getParameter< edm::InputTag >("MCTopsPt");
MCTopsPhi_ = iConfig.getParameter< edm::InputTag >("MCTopsPhi");
MCTopsEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopsEnergy");
MCTopsPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopsPdgId");
MCTopsMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopsMotherId");
MCTopBQuarksEta_ = iConfig.getParameter< edm::InputTag >("MCTopBQuarksEta");
MCTopBQuarksPt_ = iConfig.getParameter< edm::InputTag >("MCTopBQuarksPt");
MCTopBQuarksPhi_ = iConfig.getParameter< edm::InputTag >("MCTopBQuarksPhi");
MCTopBQuarksEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopBQuarksEnergy");
MCTopBQuarksPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopBQuarksPdgId");
MCTopBQuarksMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopBQuarksMotherId");
MCTopLeptonsEta_ = iConfig.getParameter< edm::InputTag >("MCTopLeptonsEta");
MCTopLeptonsPt_ = iConfig.getParameter< edm::InputTag >("MCTopLeptonsPt");
MCTopLeptonsPhi_ = iConfig.getParameter< edm::InputTag >("MCTopLeptonsPhi");
MCTopLeptonsEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopLeptonsEnergy");
MCTopLeptonsPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopLeptonsPdgId");
MCTopLeptonsMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopLeptonsMotherId");
MCTopNeutrinosEta_ = iConfig.getParameter< edm::InputTag >("MCTopNeutrinosEta");
MCTopNeutrinosPt_ = iConfig.getParameter< edm::InputTag >("MCTopNeutrinosPt");
MCTopNeutrinosPhi_ = iConfig.getParameter< edm::InputTag >("MCTopNeutrinosPhi");
MCTopNeutrinosEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopNeutrinosEnergy");
MCTopNeutrinosPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopNeutrinosPdgId");
MCTopNeutrinosMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopNeutrinosMotherId");
MCTopQuarksEta_ = iConfig.getParameter< edm::InputTag >("MCTopQuarksEta");
MCTopQuarksPt_ = iConfig.getParameter< edm::InputTag >("MCTopQuarksPt");
MCTopQuarksPhi_ = iConfig.getParameter< edm::InputTag >("MCTopQuarksPhi");
MCTopQuarksEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopQuarksEnergy");
MCTopQuarksPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopQuarksPdgId");
MCTopQuarksMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopQuarksMotherId");
MCTopQuarkBarsEta_ = iConfig.getParameter< edm::InputTag >("MCTopQuarkBarsEta");
MCTopQuarkBarsPt_ = iConfig.getParameter< edm::InputTag >("MCTopQuarkBarsPt");
MCTopQuarkBarsPhi_ = iConfig.getParameter< edm::InputTag >("MCTopQuarkBarsPhi");
MCTopQuarkBarsEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopQuarkBarsEnergy");
MCTopQuarkBarsPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopQuarkBarsPdgId");
MCTopQuarkBarsMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopQuarkBarsMotherId");
MCTopWsEta_ = iConfig.getParameter< edm::InputTag >("MCTopWsEta");
MCTopWsPt_ = iConfig.getParameter< edm::InputTag >("MCTopWsPt");
MCTopWsPhi_ = iConfig.getParameter< edm::InputTag >("MCTopWsPhi");
MCTopWsEnergy_ = iConfig.getParameter< edm::InputTag >("MCTopWsEnergy");
MCTopWsPdgId_ = iConfig.getParameter< edm::InputTag >("MCTopWsPdgId");
MCTopWsMotherId_ = iConfig.getParameter< edm::InputTag >("MCTopWsMotherId");
MCTopWsDauOneId_ = iConfig.getParameter< edm::InputTag >("MCTopWsDauOneId");
string season = "Summer11";
season = dataPUFile_;
string distr = "pileUpDistr" + season + ".root";
if (doPU_)
{
LumiWeights_ = edm::LumiReWeighting(distr,
"pileUpData.root",
std::string("pileup"),
std::string("pileup"));
LumiWeightsUp_ = edm::LumiReWeighting(distr,
"pileUpDataUp.root",
std::string("pileup"),
std::string("pileup"));
LumiWeightsDown_ = edm::LumiReWeighting(distr,
"pileUpDataDown.root",
std::string("pileup"),
std::string("pileup"));
}
Service<TFileService> fs;
systematics.insert(systematics.begin(), "noSyst");
std::vector<std::string> all_syst = systematics;
TFileDirectory SingleTopSystematics = fs->mkdir( "systematics_histograms" );
TFileDirectory SingleTopTrees = fs->mkdir( "systematics_trees" );
for (size_t i = 0; i < rate_systematics.size(); ++i)
{
all_syst.push_back(rate_systematics.at(i));
}
for (size_t i = 0; i < all_syst.size(); ++i)
{
string syst = all_syst[i];
if (doJetTrees_)
{
string treenameJets = (channel + "_NJets_" + syst);
treesNJets[syst] = new TTree(treenameJets.c_str(), treenameJets.c_str());
//Create INT branches first
treesNJets[syst]->Branch("charge", &chargeTree);
treesNJets[syst]->Branch("runid", &runTree);
treesNJets[syst]->Branch("lumiid", &lumiTree);
treesNJets[syst]->Branch("eventid", &eventTree);
treesNJets[syst]->Branch("weight", &weightTree);
treesNJets[syst]->Branch("eventFlavour", &eventFlavourTree);
treesNJets[syst]->Branch("nJ", &nJ);
treesNJets[syst]->Branch("nJNoPU", &nJNoPU);
treesNJets[syst]->Branch("nJCentral", &nJCentral);
treesNJets[syst]->Branch("nJCentralNoPU", &nJCentralNoPU);
treesNJets[syst]->Branch("nJForward", &nJForward);
treesNJets[syst]->Branch("nJForwardNoPU", &nJForwardNoPU);
treesNJets[syst]->Branch("nVertices", &nVertices);
treesNJets[syst]->Branch("nGoodVertices", &npv);
treesNJets[syst]->Branch("nTCHPT", &ntchpt_tags);
treesNJets[syst]->Branch("nCSVT", &ncsvt_tags);
treesNJets[syst]->Branch("nCSVL", &ncsvm_tags);
treesNJets[syst]->Branch("secondJetFlavour", &secondJetFlavourTree);
treesNJets[syst]->Branch("firstJetFlavour", &firstJetFlavourTree);
treesNJets[syst]->Branch("thirdJetFlavour", &thirdJetFlavourTree);
//Now create DOUBLE branches
treesNJets[syst]->Branch("w1TCHPT", &w1TCHPT);
treesNJets[syst]->Branch("w2TCHPT", &w2TCHPT);
treesNJets[syst]->Branch("w1CSVT", &w1CSVT);
treesNJets[syst]->Branch("w2CSVT", &w2CSVT);
treesNJets[syst]->Branch("w1CSVL", &w1CSVM);
treesNJets[syst]->Branch("w2CSVL", &w2CSVM);
treesNJets[syst]->Branch("PUWeight", &PUWeightTree);
treesNJets[syst]->Branch("turnOnWeight", &turnOnWeightTree);
treesNJets[syst]->Branch("turnOnReWeight", &turnOnReWeightTree);
treesNJets[syst]->Branch("leptonPt", &lepPt);
treesNJets[syst]->Branch("leptonEta", &lepEta);
treesNJets[syst]->Branch("leptonPhi", &lepPhi);
treesNJets[syst]->Branch("leptonDeltaCorrectedRelIso", &lepDeltaCorrectedRelIso);
treesNJets[syst]->Branch("leptonRhoCorrectedRelIso", &lepRhoCorrectedRelIso);
treesNJets[syst]->Branch("leptonEff", &lepEff);
treesNJets[syst]->Branch("leptonEffB", &lepEffB);
treesNJets[syst]->Branch("leptonSF", &lepSF);
treesNJets[syst]->Branch("leptonSFB", &lepSFB);
treesNJets[syst]->Branch("leptonSFC", &lepSFC);
treesNJets[syst]->Branch("leptonSFD", &lepSFD);
treesNJets[syst]->Branch("ID", &electronID);
treesNJets[syst]->Branch("MVAID", &leptonMVAID);
// treesNJets[syst]->Branch("lepNH", &leptonNHits);
treesNJets[syst]->Branch("mtwMass", &mtwMassTree);
treesNJets[syst]->Branch("metPt", &metPt);
treesNJets[syst]->Branch("metPhi", &metPhi);
treesNJets[syst]->Branch("HT", &HT);
treesNJets[syst]->Branch("firstJetPt", &firstJetPt);
treesNJets[syst]->Branch("firstJetEta", &firstJetEta);
treesNJets[syst]->Branch("firstJetPhi", &firstJetPhi);
treesNJets[syst]->Branch("firstJetE", &firstJetE);
treesNJets[syst]->Branch("thirdJetPt", &thirdJetPt);
treesNJets[syst]->Branch("thirdJetEta", &thirdJetEta);
treesNJets[syst]->Branch("thirdJetPhi", &thirdJetPhi);
treesNJets[syst]->Branch("thirdJetE", &thirdJetE);
treesNJets[syst]->Branch("secondJetPt", &secondJetPt);
treesNJets[syst]->Branch("secondJetEta", &secondJetEta);
treesNJets[syst]->Branch("secondJetPhi", &secondJetPhi);
treesNJets[syst]->Branch("secondJetE", &secondJetE);
treesNJets[syst]->Branch("bJetPt", &bJetPt);
treesNJets[syst]->Branch("fJetPt", &fJetPt);
treesNJets[syst]->Branch("fJetEta", &fJetEta);
treesNJets[syst]->Branch("bJetEta", &bJetEta);
treesNJets[syst]->Branch("fJetPUID", &fJetPUID);
treesNJets[syst]->Branch("fJetPUWP", &fJetPUWP);
treesNJets[syst]->Branch("isQCD", &isQCDTree);
//58 lines
treesNJets[syst]->Branch("fJetBeta", &fJetBeta);
treesNJets[syst]->Branch("fJetDZ", &fJetDZ);
treesNJets[syst]->Branch("fJetRMS", &fJetRMS);
treesNJets[syst]->Branch("bJetBeta", &bJetBeta);
treesNJets[syst]->Branch("bJetDZ", &bJetDZ);
treesNJets[syst]->Branch("bJetRMS", &bJetRMS);
if(addPDFToNJets){
for (int p = 1; p <= 52; ++p)
{
stringstream w_n;
w_n << p;
treesNJets[syst]->Branch(("PDFWeight" + w_n.str()).c_str(), &pdf_weights[p - 1]);
}
treesNJets[syst]->Branch("PDFWeight_MSTW", &pdf_weights_mstw);
treesNJets[syst]->Branch("PDFWeight_NNPDF21", &pdf_weights_nnpdf21);
treesNJets[syst]->Branch("PDFWeight_GJR_FV", &pdf_weights_gjr_fv);
treesNJets[syst]->Branch("PDFWeight_GJR_FF", &pdf_weights_gjr_ff);
treesNJets[syst]->Branch("PDFWeight_GJR_FDIS", &pdf_weights_gjr_fdis);
treesNJets[syst]->Branch("PDFWeight_HERAPDF", &pdf_weights_alekhin);
}
}
for (int bj = 0; bj <= 5; ++bj)
{
stringstream tags;
int ntagss = bj;
if (ntagss > 2 )
{
ntagss = ntagss - 3;
tags << ntagss;
tags << "T_QCD";
}
else
{
tags << ntagss << "T";
}
//2J1T
string treename = (channel + "_2J_" + tags.str() + "_" + syst);
trees2J[bj][syst] = new TTree(treename.c_str(), treename.c_str());
//quantities for the analysis
trees2J[bj][syst]->Branch("eta", &etaTree);
trees2J[bj][syst]->Branch("costhetalj", &cosTree);
trees2J[bj][syst]->Branch("costhetalbl", &cosBLTree);
trees2J[bj][syst]->Branch("mtwMass", &mtwMassTree);
trees2J[bj][syst]->Branch("charge", &chargeTree);
trees2J[bj][syst]->Branch("runid", &runTree);
trees2J[bj][syst]->Branch("lumiid", &lumiTree);
trees2J[bj][syst]->Branch("eventid", &eventTree);
trees2J[bj][syst]->Branch("weight", &weightTree);
trees2J[bj][syst]->Branch("totalWeight", &totalWeightTree);
trees2J[bj][syst]->Branch("bWeight", &bWeightTree);
//Systematics b weights
trees2J[bj][syst]->Branch("bWeightBTagUp", &bWeightTreeBTagUp);
trees2J[bj][syst]->Branch("bWeightBTagDown", &bWeightTreeBTagDown);
trees2J[bj][syst]->Branch("bWeightMisTagUp", &bWeightTreeMisTagUp);
trees2J[bj][syst]->Branch("bWeightMisTagDown", &bWeightTreeMisTagDown);
//Systematics pile up weights
trees2J[bj][syst]->Branch("PUWeight", &PUWeightTree);
trees2J[bj][syst]->Branch("PUWeightPUUp", &PUWeightTreePUUp);
trees2J[bj][syst]->Branch("PUWeightPUDown", &PUWeightTreePUDown);
//Systematics turn on weights
trees2J[bj][syst]->Branch("turnOnWeight", &turnOnWeightTree);
trees2J[bj][syst]->Branch("turnOnReWeight", &turnOnReWeightTree);
trees2J[bj][syst]->Branch("turnOnWeightJetTrig1Up", &turnOnWeightTreeJetTrig1Up);
trees2J[bj][syst]->Branch("turnOnWeightJetTrig1Down", &turnOnWeightTreeJetTrig1Down);
trees2J[bj][syst]->Branch("turnOnWeightJetTrig2Up", &turnOnWeightTreeJetTrig2Up);
trees2J[bj][syst]->Branch("turnOnWeightJetTrig2Down", &turnOnWeightTreeJetTrig2Down);
trees2J[bj][syst]->Branch("turnOnWeightJetTrig3Up", &turnOnWeightTreeJetTrig3Up);
trees2J[bj][syst]->Branch("turnOnWeightJetTrig3Down", &turnOnWeightTreeJetTrig3Down);
trees2J[bj][syst]->Branch("turnOnWeightBTagTrig1Up", &turnOnWeightTreeBTagTrig1Up);
trees2J[bj][syst]->Branch("turnOnWeightBTagTrig1Down", &turnOnWeightTreeBTagTrig1Down);
trees2J[bj][syst]->Branch("turnOnWeightBTagTrig2Up", &turnOnWeightTreeBTagTrig2Up);
trees2J[bj][syst]->Branch("turnOnWeightBTagTrig2Down", &turnOnWeightTreeBTagTrig2Down);
trees2J[bj][syst]->Branch("turnOnWeightBTagTrig3Up", &turnOnWeightTreeBTagTrig3Up);
trees2J[bj][syst]->Branch("turnOnWeightBTagTrig3Down", &turnOnWeightTreeBTagTrig3Down);
//other observables
trees2J[bj][syst]->Branch("leptonPt", &lepPt);
trees2J[bj][syst]->Branch("leptonEta", &lepEta);
trees2J[bj][syst]->Branch("leptonPhi", &lepPhi);
trees2J[bj][syst]->Branch("leptonDeltaCorrectedRelIso", &lepDeltaCorrectedRelIso);
trees2J[bj][syst]->Branch("leptonRhoCorrectedRelIso", &lepRhoCorrectedRelIso);
trees2J[bj][syst]->Branch("leptonEff", &lepEff);
trees2J[bj][syst]->Branch("leptonEffB", &lepEffB);
trees2J[bj][syst]->Branch("leptonSF", &lepSF);
trees2J[bj][syst]->Branch("leptonSFB", &lepSFB);
trees2J[bj][syst]->Branch("leptonSFC", &lepSFC);
trees2J[bj][syst]->Branch("leptonSFD", &lepSFD);
//
trees2J[bj][syst]->Branch("leptonSFIDUp", &lepSFIDUp);
trees2J[bj][syst]->Branch("leptonSFIDUpB", &lepSFIDUpB);
trees2J[bj][syst]->Branch("leptonSFIDUpC", &lepSFIDUpC);
trees2J[bj][syst]->Branch("leptonSFIDUpD", &lepSFIDUpD);
trees2J[bj][syst]->Branch("leptonSFIDDown", &lepSFIDDown);
trees2J[bj][syst]->Branch("leptonSFIDDownB", &lepSFIDDownB);
trees2J[bj][syst]->Branch("leptonSFIDDownC", &lepSFIDDownC);
trees2J[bj][syst]->Branch("leptonSFIDDownD", &lepSFIDDownD);
//
trees2J[bj][syst]->Branch("leptonSFIsoUp", &lepSFIsoUp);
trees2J[bj][syst]->Branch("leptonSFIsoUpB", &lepSFIsoUpB);
trees2J[bj][syst]->Branch("leptonSFIsoUpC", &lepSFIsoUpC);
trees2J[bj][syst]->Branch("leptonSFIsoUpD", &lepSFIsoUpD);
trees2J[bj][syst]->Branch("leptonSFIsoDown", &lepSFIsoDown);
trees2J[bj][syst]->Branch("leptonSFIsoDownB", &lepSFIsoDownB);
trees2J[bj][syst]->Branch("leptonSFIsoDownC", &lepSFIsoDownC);
trees2J[bj][syst]->Branch("leptonSFIsoDownD", &lepSFIsoDownD);
//
trees2J[bj][syst]->Branch("leptonSFTrigUp", &lepSFTrigUp);
trees2J[bj][syst]->Branch("leptonSFTrigUpB", &lepSFTrigUpB);
trees2J[bj][syst]->Branch("leptonSFTrigUpC", &lepSFTrigUpC);
trees2J[bj][syst]->Branch("leptonSFTrigUpD", &lepSFTrigUpD);
trees2J[bj][syst]->Branch("leptonSFTrigDown", &lepSFTrigDown);
trees2J[bj][syst]->Branch("leptonSFTrigDownB", &lepSFTrigDownB);
trees2J[bj][syst]->Branch("leptonSFTrigDownC", &lepSFTrigDownC);
trees2J[bj][syst]->Branch("leptonSFTrigDownD", &lepSFTrigDownD);
//
trees2J[bj][syst]->Branch("fJetPt", &fJetPt);
trees2J[bj][syst]->Branch("fJetE", &fJetE);
trees2J[bj][syst]->Branch("fJetEta", &fJetEta);
trees2J[bj][syst]->Branch("fJetPhi", &fJetPhi);
trees2J[bj][syst]->Branch("fJetBtag", &fJetBTag);
trees2J[bj][syst]->Branch("fJetFlavour", &fJetFlavourTree);
trees2J[bj][syst]->Branch("fJetPUID", &fJetPUID);
trees2J[bj][syst]->Branch("fJetPUWP", &fJetPUWP);
trees2J[bj][syst]->Branch("fJetBeta", &fJetBeta);
trees2J[bj][syst]->Branch("fJetDZ", &fJetDZ);
trees2J[bj][syst]->Branch("fJetRMS", &fJetRMS);
trees2J[bj][syst]->Branch("bJetBeta", &bJetBeta);
trees2J[bj][syst]->Branch("bJetDZ", &bJetDZ);
trees2J[bj][syst]->Branch("bJetRMS", &bJetRMS);
trees2J[bj][syst]->Branch("bJetPt", &bJetPt);
trees2J[bj][syst]->Branch("bJetE", &bJetE);
trees2J[bj][syst]->Branch("bJetEta", &bJetEta);
trees2J[bj][syst]->Branch("bJetPhi", &bJetPhi);
trees2J[bj][syst]->Branch("bJetBtag", &bJetBTag);
trees2J[bj][syst]->Branch("bJetFlavour", &bJetFlavourTree);
trees2J[bj][syst]->Branch("bJetPUID", &bJetPUID);
trees2J[bj][syst]->Branch("bJetPUWP", &bJetPUWP);
trees2J[bj][syst]->Branch("firstJetPt", &firstJetPt);
trees2J[bj][syst]->Branch("firstJetEta", &firstJetEta);
trees2J[bj][syst]->Branch("firstJetPhi", &firstJetPhi);
trees2J[bj][syst]->Branch("firstJetE", &firstJetE);
trees2J[bj][syst]->Branch("firstJetFlavour", &firstJetFlavourTree);
trees2J[bj][syst]->Branch("secondJetPt", &secondJetPt);
trees2J[bj][syst]->Branch("secondJetEta", &secondJetEta);
trees2J[bj][syst]->Branch("secondJetPhi", &secondJetPhi);
trees2J[bj][syst]->Branch("secondJetE", &secondJetE);
trees2J[bj][syst]->Branch("secondJetFlavour", &secondJetFlavourTree);
trees2J[bj][syst]->Branch("eventFlavour", &eventFlavourTree);
trees2J[bj][syst]->Branch("metPt", &metPt);
trees2J[bj][syst]->Branch("metPhi", &metPhi);
trees2J[bj][syst]->Branch("HT", &HT);
trees2J[bj][syst]->Branch("topMass", &topMassTree);
trees2J[bj][syst]->Branch("topMtw", &topMtwTree);
trees2J[bj][syst]->Branch("topPt", &topPt);
trees2J[bj][syst]->Branch("topPhi", &topPhi);
trees2J[bj][syst]->Branch("topEta", &topEta);
trees2J[bj][syst]->Branch("topE", &topE);
trees2J[bj][syst]->Branch("ID", &electronID);
trees2J[bj][syst]->Branch("MVAID", &leptonMVAID);
// trees2J[bj][syst]->Branch("lepNH", &leptonNHits);
trees2J[bj][syst]->Branch("nVertices", &nVertices);
trees2J[bj][syst]->Branch("nGoodVertices", &npv);
trees2J[bj][syst]->Branch("totalEnergy", &totalEnergy);
trees2J[bj][syst]->Branch("totalMomentum", &totalMomentum);
trees2J[bj][syst]->Branch("lowBTag", &lowBTagTree);
trees2J[bj][syst]->Branch("highBTag", &highBTagTree);
if(doMCTruth_ && bj == 1 && syst == "noSyst" ){
for (int p = 1; p <= 2; ++p)
{
stringstream w_n;
w_n << p;
TString num( w_n.str() );
num = "_"+num+"_";
trees2J[bj][syst]->Branch("nMCTruthLeptons", &nMCTruthLeptons);
trees2J[bj][syst]->Branch("MCTop"+num+"Pt", &MCTopsPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTop"+num+"Phi", &MCTopsPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTop"+num+"Eta", &MCTopsEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTop"+num+"E", &MCTopsEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTop"+num+"PdgId", &MCTopsPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTop"+num+"MotherId", &MCTopsMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopLepton"+num+"Pt", &MCTopLeptonsPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTopLepton"+num+"Phi", &MCTopLeptonsPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTopLepton"+num+"Eta", &MCTopLeptonsEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTopLepton"+num+"E", &MCTopLeptonsEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTopLepton"+num+"PdgId", &MCTopLeptonsPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopLepton"+num+"MotherId", &MCTopLeptonsMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopNeutrino"+num+"Pt", &MCTopNeutrinosPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTopNeutrino"+num+"Phi", &MCTopNeutrinosPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTopNeutrino"+num+"Eta", &MCTopNeutrinosEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTopNeutrino"+num+"E", &MCTopNeutrinosEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTopNeutrino"+num+"PdgId", &MCTopNeutrinosPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopNeutrino"+num+"MotherId", &MCTopNeutrinosMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuark"+num+"Pt", &MCTopQuarksPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuark"+num+"Phi", &MCTopQuarksPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuark"+num+"Eta", &MCTopQuarksEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuark"+num+"E", &MCTopQuarksEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuark"+num+"PdgId", &MCTopQuarksPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuark"+num+"MotherId", &MCTopQuarksMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuarkBar"+num+"Pt", &MCTopQuarkBarsPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuarkBar"+num+"Phi", &MCTopQuarkBarsPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuarkBar"+num+"Eta", &MCTopQuarkBarsEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuarkBar"+num+"E", &MCTopQuarkBarsEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuarkBar"+num+"PdgId", &MCTopQuarkBarsPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopQuarkBar"+num+"MotherId", &MCTopQuarkBarsMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopBQuark"+num+"Pt", &MCTopBQuarksPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTopBQuark"+num+"Phi", &MCTopBQuarksPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTopBQuark"+num+"Eta", &MCTopBQuarksEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTopBQuark"+num+"E", &MCTopBQuarksEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTopBQuark"+num+"PdgId", &MCTopBQuarksPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopBQuark"+num+"MotherId", &MCTopBQuarksMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopW"+num+"Pt", &MCTopWsPtVec[p-1]);
trees2J[bj][syst]->Branch("MCTopW"+num+"Phi", &MCTopWsPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCTopW"+num+"Eta", &MCTopWsEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCTopW"+num+"E", &MCTopWsEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCTopW"+num+"PdgId", &MCTopWsPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCTopW"+num+"DauOneId", &MCTopWsDauOneIdVec[p-1]);
}
for (int p = 1; p <= 12; ++p)
{
stringstream w_n;
w_n << p;
TString num( w_n.str() );
num = "_"+num+"_";
trees2J[bj][syst]->Branch("MCQuark"+num+"Pt", &MCQuarksPtVec[p-1]);
trees2J[bj][syst]->Branch("MCQuark"+num+"Phi", &MCQuarksPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCQuark"+num+"Eta", &MCQuarksEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCQuark"+num+"E", &MCQuarksEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCQuark"+num+"PdgId", &MCQuarksPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCQuark"+num+"MotherId", &MCQuarksMotherIdVec[p-1]);
}
for (int p = 1; p <= 4; ++p)
{
stringstream w_n;
w_n << p;
TString num( w_n.str() );
num = "_"+num+"_";
trees2J[bj][syst]->Branch("MCBQuark"+num+"Pt", &MCBQuarksPtVec[p-1]);
trees2J[bj][syst]->Branch("MCBQuark"+num+"Phi", &MCBQuarksPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCBQuark"+num+"Eta", &MCBQuarksEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCBQuark"+num+"E", &MCBQuarksEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCBQuark"+num+"PdgId", &MCBQuarksPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCBQuark"+num+"MotherId", &MCBQuarksMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCLepton"+num+"Pt", &MCLeptonsPtVec[p-1]);
trees2J[bj][syst]->Branch("MCLepton"+num+"Phi", &MCLeptonsPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCLepton"+num+"Eta", &MCLeptonsEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCLepton"+num+"E", &MCLeptonsEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCLepton"+num+"PdgId", &MCLeptonsPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCLepton"+num+"MotherId", &MCLeptonsMotherIdVec[p-1]);
trees2J[bj][syst]->Branch("MCNeutrino"+num+"Pt", &MCNeutrinosPtVec[p-1]);
trees2J[bj][syst]->Branch("MCNeutrino"+num+"Phi", &MCNeutrinosPhiVec[p-1]);
trees2J[bj][syst]->Branch("MCNeutrino"+num+"Eta", &MCNeutrinosEtaVec[p-1]);
trees2J[bj][syst]->Branch("MCNeutrino"+num+"E", &MCNeutrinosEnergyVec[p-1]);
trees2J[bj][syst]->Branch("MCNeutrino"+num+"PdgId", &MCNeutrinosPdgIdVec[p-1]);
trees2J[bj][syst]->Branch("MCNeutrino"+num+"MotherId", &MCNeutrinosMotherIdVec[p-1]);
}
}
for (int p = 1; p <= 52; ++p)
{
stringstream w_n;
w_n << p;
trees2J[bj][syst]->Branch(("PDFWeight" + w_n.str()).c_str(), &pdf_weights[p - 1]);
}
trees2J[bj][syst]->Branch("PDFWeight_MSTW", &pdf_weights_mstw);
trees2J[bj][syst]->Branch("PDFWeight_NNPDF21", &pdf_weights_nnpdf21);
trees2J[bj][syst]->Branch("PDFWeight_GJR_FV", &pdf_weights_gjr_fv);
trees2J[bj][syst]->Branch("PDFWeight_GJR_FF", &pdf_weights_gjr_ff);
trees2J[bj][syst]->Branch("PDFWeight_GJR_FDIS", &pdf_weights_gjr_fdis);
trees2J[bj][syst]->Branch("PDFWeight_HERAPDF", &pdf_weights_alekhin);
treename = (channel + "_3J_" + tags.str() + "_" + syst);
trees3J[bj][syst] = new TTree(treename.c_str(), treename.c_str());
//basic quantities
trees3J[bj][syst]->Branch("eta", &etaTree);
trees3J[bj][syst]->Branch("costhetalj", &cosTree);
trees3J[bj][syst]->Branch("costhetalbl", &cosBLTree);
trees3J[bj][syst]->Branch("topMass", &topMassTree);
trees3J[bj][syst]->Branch("topMtw", &topMtwTree);
trees3J[bj][syst]->Branch("HT", &HT);
trees3J[bj][syst]->Branch("mtwMass", &mtwMassTree);
trees3J[bj][syst]->Branch("charge", &chargeTree);
trees3J[bj][syst]->Branch("runid", &runTree);
trees3J[bj][syst]->Branch("lumiid", &lumiTree);
trees3J[bj][syst]->Branch("eventid", &eventTree);
trees3J[bj][syst]->Branch("weight", &weightTree);
//trees2J[bj][syst]->Branch("weightTmp",&weightTree);
trees3J[bj][syst]->Branch("totalWeight", &totalWeightTree);
//Extra info
trees3J[bj][syst]->Branch("leptonPt", &lepPt);
trees3J[bj][syst]->Branch("leptonEta", &lepEta);
trees3J[bj][syst]->Branch("leptonPhi", &lepPhi);
trees3J[bj][syst]->Branch("leptonDeltaCorrectedRelIso", &lepDeltaCorrectedRelIso);
trees3J[bj][syst]->Branch("leptonRhoCorrectedRelIso", &lepRhoCorrectedRelIso);
trees3J[bj][syst]->Branch("leptonEff", &lepEff);
trees3J[bj][syst]->Branch("leptonEffB", &lepEffB);
trees3J[bj][syst]->Branch("leptonSF", &lepSF);
trees3J[bj][syst]->Branch("leptonSFB", &lepSFB);
trees3J[bj][syst]->Branch("leptonSFC", &lepSFC);
// trees3J[bj][syst]->Branch("leptonSFD", &lepSFD);
trees3J[bj][syst]->Branch("fJetPt", &fJetPt);
trees3J[bj][syst]->Branch("fJetE", &fJetE);
trees3J[bj][syst]->Branch("fJetEta", &fJetEta);
trees3J[bj][syst]->Branch("fJetPhi", &fJetPhi);
trees3J[bj][syst]->Branch("fJetBtag", &fJetBTag);
trees3J[bj][syst]->Branch("fJetFlavour", &fJetFlavourTree);
trees3J[bj][syst]->Branch("fJetPUID", &fJetPUID);
trees3J[bj][syst]->Branch("fJetPUWP", &fJetPUWP);
trees3J[bj][syst]->Branch("fJetBeta", &fJetBeta);
trees3J[bj][syst]->Branch("fJetDZ", &fJetDZ);
trees3J[bj][syst]->Branch("fJetRMS", &fJetRMS);
trees3J[bj][syst]->Branch("bJetBeta", &bJetBeta);
trees3J[bj][syst]->Branch("bJetDZ", &bJetDZ);
trees3J[bj][syst]->Branch("bJetRMS", &bJetRMS);
trees3J[bj][syst]->Branch("bJetPt", &bJetPt);
trees3J[bj][syst]->Branch("bJetE", &bJetE);
trees3J[bj][syst]->Branch("bJetEta", &bJetEta);
trees3J[bj][syst]->Branch("bJetPhi", &bJetPhi);
trees3J[bj][syst]->Branch("bJetBtag", &bJetBTag);
trees3J[bj][syst]->Branch("bJetFlavour", &bJetFlavourTree);
trees3J[bj][syst]->Branch("bJetPUID", &bJetPUID);
trees3J[bj][syst]->Branch("bJetPUWP", &bJetPUWP);
trees3J[bj][syst]->Branch("firstJetPt", &firstJetPt);
trees3J[bj][syst]->Branch("firstJetEta", &firstJetEta);
trees3J[bj][syst]->Branch("firstJetPhi", &firstJetPhi);
trees3J[bj][syst]->Branch("firstJetE", &firstJetE);
trees3J[bj][syst]->Branch("firstJetFlavour", &firstJetFlavourTree);
trees3J[bj][syst]->Branch("secondJetPt", &secondJetPt);
trees3J[bj][syst]->Branch("secondJetEta", &secondJetEta);
trees3J[bj][syst]->Branch("secondJetPhi", &secondJetPhi);
trees3J[bj][syst]->Branch("secondJetE", &secondJetE);
trees3J[bj][syst]->Branch("secondJetFlavour", &secondJetFlavourTree);
trees3J[bj][syst]->Branch("thirdJetPt", &thirdJetPt);
trees3J[bj][syst]->Branch("thirdJetEta", &thirdJetEta);
trees3J[bj][syst]->Branch("thirdJetPhi", &thirdJetPhi);
trees3J[bj][syst]->Branch("thirdJetE", &thirdJetE);
trees3J[bj][syst]->Branch("thirdJetFlavour", &thirdJetFlavourTree);
trees3J[bj][syst]->Branch("eventFlavour", &eventFlavourTree);
trees3J[bj][syst]->Branch("metPt", &metPt);
trees3J[bj][syst]->Branch("metPhi", &metPhi);
trees3J[bj][syst]->Branch("topPt", &topPt);
trees3J[bj][syst]->Branch("topPhi", &topPhi);
trees3J[bj][syst]->Branch("topEta", &topEta);
trees3J[bj][syst]->Branch("topE", &topE);
trees3J[bj][syst]->Branch("ID", &electronID);
trees3J[bj][syst]->Branch("MVAID", &leptonMVAID);
// trees3J[bj][syst]->Branch("lepNH", &leptonNHits);
trees3J[bj][syst]->Branch("nVertices", &nVertices);
trees3J[bj][syst]->Branch("nGoodVertices", &npv);
trees3J[bj][syst]->Branch("totalEnergy", &totalEnergy);
trees3J[bj][syst]->Branch("totalMomentum", &totalMomentum);
trees3J[bj][syst]->Branch("lowBTag", &lowBTagTree);
trees3J[bj][syst]->Branch("highBTag", &highBTagTree);
//Systematics b weights
trees3J[bj][syst]->Branch("bWeight", &bWeightTree);
trees3J[bj][syst]->Branch("bWeightBTagUp", &bWeightTreeBTagUp);
trees3J[bj][syst]->Branch("bWeightBTagDown", &bWeightTreeBTagDown);
trees3J[bj][syst]->Branch("bWeightMisTagUp", &bWeightTreeMisTagUp);
trees3J[bj][syst]->Branch("bWeightMisTagDown", &bWeightTreeMisTagDown);
//Systematics pile up weights
trees3J[bj][syst]->Branch("PUWeight", &PUWeightTree);
trees3J[bj][syst]->Branch("PUWeightPUUp", &PUWeightTreePUUp);
trees3J[bj][syst]->Branch("PUWeightPUDown", &PUWeightTreePUDown);
//Systematics turn on weights
trees3J[bj][syst]->Branch("turnOnWeight", &turnOnWeightTree);
trees3J[bj][syst]->Branch("turnOnReWeight", &turnOnReWeightTree);
trees3J[bj][syst]->Branch("turnOnWeightJetTrig1Up", &turnOnWeightTreeJetTrig1Up);
trees3J[bj][syst]->Branch("turnOnWeightJetTrig1Down", &turnOnWeightTreeJetTrig1Down);
trees3J[bj][syst]->Branch("turnOnWeightJetTrig2Up", &turnOnWeightTreeJetTrig2Up);
trees3J[bj][syst]->Branch("turnOnWeightJetTrig2Down", &turnOnWeightTreeJetTrig2Down);
trees3J[bj][syst]->Branch("turnOnWeightJetTrig3Up", &turnOnWeightTreeJetTrig3Up);
trees3J[bj][syst]->Branch("turnOnWeightJetTrig3Down", &turnOnWeightTreeJetTrig3Down);
trees3J[bj][syst]->Branch("turnOnWeightBTagTrig1Up", &turnOnWeightTreeBTagTrig1Up);
trees3J[bj][syst]->Branch("turnOnWeightBTagTrig1Down", &turnOnWeightTreeBTagTrig1Down);
trees3J[bj][syst]->Branch("turnOnWeightBTagTrig2Up", &turnOnWeightTreeBTagTrig2Up);
trees3J[bj][syst]->Branch("turnOnWeightBTagTrig2Down", &turnOnWeightTreeBTagTrig2Down);
trees3J[bj][syst]->Branch("turnOnWeightBTagTrig3Up", &turnOnWeightTreeBTagTrig3Up);
trees3J[bj][syst]->Branch("turnOnWeightBTagTrig3Down", &turnOnWeightTreeBTagTrig3Down);
for (int p = 1; p <= 52; ++p)
{
stringstream w_n;
w_n << p;
trees3J[bj][syst]->Branch(("PDFWeight" + w_n.str()).c_str(), &pdf_weights[p - 1]);
}
trees3J[bj][syst]->Branch("PDFWeight_MSTW", &pdf_weights_mstw);
trees3J[bj][syst]->Branch("PDFWeight_NNPDF21", &pdf_weights_nnpdf21);
trees3J[bj][syst]->Branch("PDFWeight_GJR_FV", &pdf_weights_gjr_fv);
trees3J[bj][syst]->Branch("PDFWeight_GJR_FF", &pdf_weights_gjr_ff);
trees3J[bj][syst]->Branch("PDFWeight_GJR_FDIS", &pdf_weights_gjr_fdis);
trees3J[bj][syst]->Branch("PDFWeight_HERAPDF", &pdf_weights_alekhin);
}
if(doMCTruth_ && doFullMCTruth_ && syst == "noSyst" ){
string treenameMCTruth = (channel + "_MCTruth_" + syst);
treesMCTruth = new TTree(treenameMCTruth.c_str(), treenameMCTruth.c_str());
for (int p = 1; p <= 2; ++p)
{
stringstream w_n;
w_n << p;
TString num( w_n.str() );
num = "_"+num+"_";
treesMCTruth->Branch("runid", &runTree);
treesMCTruth->Branch("lumiid", &lumiTree);
treesMCTruth->Branch("eventid", &eventTree);
treesMCTruth->Branch("nMCTruthLeptons", &nMCTruthLeptons);
treesMCTruth->Branch("MCTop"+num+"Pt", &MCTopsPtVec[p-1]);
treesMCTruth->Branch("MCTop"+num+"Phi", &MCTopsPhiVec[p-1]);
treesMCTruth->Branch("MCTop"+num+"Eta", &MCTopsEtaVec[p-1]);
treesMCTruth->Branch("MCTop"+num+"E", &MCTopsEnergyVec[p-1]);
treesMCTruth->Branch("MCTop"+num+"PdgId", &MCTopsPdgIdVec[p-1]);
treesMCTruth->Branch("MCTop"+num+"MotherId", &MCTopsMotherIdVec[p-1]);
treesMCTruth->Branch("MCTopLepton"+num+"Pt", &MCTopLeptonsPtVec[p-1]);
treesMCTruth->Branch("MCTopLepton"+num+"Phi", &MCTopLeptonsPhiVec[p-1]);
treesMCTruth->Branch("MCTopLepton"+num+"Eta", &MCTopLeptonsEtaVec[p-1]);
treesMCTruth->Branch("MCTopLepton"+num+"E", &MCTopLeptonsEnergyVec[p-1]);
treesMCTruth->Branch("MCTopLepton"+num+"PdgId", &MCTopLeptonsPdgIdVec[p-1]);
treesMCTruth->Branch("MCTopLepton"+num+"MotherId", &MCTopLeptonsMotherIdVec[p-1]);
treesMCTruth->Branch("MCTopNeutrino"+num+"Pt", &MCTopNeutrinosPtVec[p-1]);
treesMCTruth->Branch("MCTopNeutrino"+num+"Phi", &MCTopNeutrinosPhiVec[p-1]);
treesMCTruth->Branch("MCTopNeutrino"+num+"Eta", &MCTopNeutrinosEtaVec[p-1]);
treesMCTruth->Branch("MCTopNeutrino"+num+"E", &MCTopNeutrinosEnergyVec[p-1]);
treesMCTruth->Branch("MCTopNeutrino"+num+"PdgId", &MCTopNeutrinosPdgIdVec[p-1]);
treesMCTruth->Branch("MCTopNeutrino"+num+"MotherId", &MCTopNeutrinosMotherIdVec[p-1]);
treesMCTruth->Branch("MCTopQuark"+num+"Pt", &MCTopQuarksPtVec[p-1]);
treesMCTruth->Branch("MCTopQuark"+num+"Phi", &MCTopQuarksPhiVec[p-1]);
treesMCTruth->Branch("MCTopQuark"+num+"Eta", &MCTopQuarksEtaVec[p-1]);
treesMCTruth->Branch("MCTopQuark"+num+"E", &MCTopQuarksEnergyVec[p-1]);
treesMCTruth->Branch("MCTopQuark"+num+"PdgId", &MCTopQuarksPdgIdVec[p-1]);
treesMCTruth->Branch("MCTopQuark"+num+"MotherId", &MCTopQuarksMotherIdVec[p-1]);
treesMCTruth->Branch("MCTopQuarkBar"+num+"Pt", &MCTopQuarkBarsPtVec[p-1]);
treesMCTruth->Branch("MCTopQuarkBar"+num+"Phi", &MCTopQuarkBarsPhiVec[p-1]);
treesMCTruth->Branch("MCTopQuarkBar"+num+"Eta", &MCTopQuarkBarsEtaVec[p-1]);
treesMCTruth->Branch("MCTopQuarkBar"+num+"E", &MCTopQuarkBarsEnergyVec[p-1]);
treesMCTruth->Branch("MCTopQuarkBar"+num+"PdgId", &MCTopQuarkBarsPdgIdVec[p-1]);
treesMCTruth->Branch("MCTopQuarkBar"+num+"MotherId", &MCTopQuarkBarsMotherIdVec[p-1]);
treesMCTruth->Branch("MCTopBQuark"+num+"Pt", &MCTopBQuarksPtVec[p-1]);
treesMCTruth->Branch("MCTopBQuark"+num+"Phi", &MCTopBQuarksPhiVec[p-1]);
treesMCTruth->Branch("MCTopBQuark"+num+"Eta", &MCTopBQuarksEtaVec[p-1]);
treesMCTruth->Branch("MCTopBQuark"+num+"E", &MCTopBQuarksEnergyVec[p-1]);
treesMCTruth->Branch("MCTopBQuark"+num+"PdgId", &MCTopBQuarksPdgIdVec[p-1]);
treesMCTruth->Branch("MCTopBQuark"+num+"MotherId", &MCTopBQuarksMotherIdVec[p-1]);
treesMCTruth->Branch("MCTopW"+num+"Pt", &MCTopWsPtVec[p-1]);
treesMCTruth->Branch("MCTopW"+num+"Phi", &MCTopWsPhiVec[p-1]);
treesMCTruth->Branch("MCTopW"+num+"Eta", &MCTopWsEtaVec[p-1]);
treesMCTruth->Branch("MCTopW"+num+"E", &MCTopWsEnergyVec[p-1]);
treesMCTruth->Branch("MCTopW"+num+"PdgId", &MCTopWsPdgIdVec[p-1]);
treesMCTruth->Branch("MCTopW"+num+"DauOneId", &MCTopWsDauOneIdVec[p-1]);
}
for (int p = 1; p <= 12; ++p)
{
stringstream w_n;
w_n << p;
TString num( w_n.str() );
num = "_"+num+"_";
treesMCTruth->Branch("MCQuark"+num+"Pt", &MCQuarksPtVec[p-1]);
treesMCTruth->Branch("MCQuark"+num+"Phi", &MCQuarksPhiVec[p-1]);
treesMCTruth->Branch("MCQuark"+num+"Eta", &MCQuarksEtaVec[p-1]);
treesMCTruth->Branch("MCQuark"+num+"E", &MCQuarksEnergyVec[p-1]);
treesMCTruth->Branch("MCQuark"+num+"PdgId", &MCQuarksPdgIdVec[p-1]);
treesMCTruth->Branch("MCQuark"+num+"MotherId", &MCQuarksMotherIdVec[p-1]);
}
for (int p = 1; p <= 4; ++p)
{
stringstream w_n;
w_n << p;
TString num( w_n.str() );
num = "_"+num+"_";
treesMCTruth->Branch("MCBQuark"+num+"Pt", &MCBQuarksPtVec[p-1]);
treesMCTruth->Branch("MCBQuark"+num+"Phi", &MCBQuarksPhiVec[p-1]);
treesMCTruth->Branch("MCBQuark"+num+"Eta", &MCBQuarksEtaVec[p-1]);
treesMCTruth->Branch("MCBQuark"+num+"E", &MCBQuarksEnergyVec[p-1]);
treesMCTruth->Branch("MCBQuark"+num+"PdgId", &MCBQuarksPdgIdVec[p-1]);
treesMCTruth->Branch("MCBQuark"+num+"MotherId", &MCBQuarksMotherIdVec[p-1]);
treesMCTruth->Branch("MCLepton"+num+"Pt", &MCLeptonsPtVec[p-1]);
treesMCTruth->Branch("MCLepton"+num+"Phi", &MCLeptonsPhiVec[p-1]);
treesMCTruth->Branch("MCLepton"+num+"Eta", &MCLeptonsEtaVec[p-1]);
treesMCTruth->Branch("MCLepton"+num+"E", &MCLeptonsEnergyVec[p-1]);
treesMCTruth->Branch("MCLepton"+num+"PdgId", &MCLeptonsPdgIdVec[p-1]);
treesMCTruth->Branch("MCLepton"+num+"MotherId", &MCLeptonsMotherIdVec[p-1]);
treesMCTruth->Branch("MCNeutrino"+num+"Pt", &MCNeutrinosPtVec[p-1]);
treesMCTruth->Branch("MCNeutrino"+num+"Phi", &MCNeutrinosPhiVec[p-1]);
treesMCTruth->Branch("MCNeutrino"+num+"Eta", &MCNeutrinosEtaVec[p-1]);
treesMCTruth->Branch("MCNeutrino"+num+"E", &MCNeutrinosEnergyVec[p-1]);
treesMCTruth->Branch("MCNeutrino"+num+"PdgId", &MCNeutrinosPdgIdVec[p-1]);
treesMCTruth->Branch("MCNeutrino"+num+"MotherId", &MCNeutrinosMotherIdVec[p-1]);
}
}
}
passingLepton = 0;
passingMuonVeto = 0;
passingLeptonVeto = 0;
passingJets = 0;
passingBJets = 0;
passingMET = 0;
//TCHPT
b_tchpt_0_tags = BTagWeight(0, 0);
b_tchpt_1_tag = BTagWeight(1, 1);
b_tchpt_2_tags = BTagWeight(2, 2);
//CSVT
b_csvt_0_tags = BTagWeight(0, 0);
b_csvt_1_tag = BTagWeight(1, 1);
b_csvt_2_tags = BTagWeight(2, 2);
//CSVM
b_csvm_0_tags = BTagWeight(0, 0);
b_csvm_1_tag = BTagWeight(1, 1);
b_csvm_2_tags = BTagWeight(2, 2);
JEC_PATH = "./";
// jecUnc = new JetCorrectionUncertainty(*(new JetCorrectorParameters("Summer12_V2_DATA_AK5PF_UncertaintySources.txt", "Total")));
jecUnc = new JetCorrectionUncertainty(*(new JetCorrectorParameters("Fall12_V7_DATA_UncertaintySources_AK5PFchs.txt", "Total")));
JES_SW = 0.0;
JES_b_cut = 0.0;
JES_b_overCut = 0.0;
//JetResolution part
string fileResolName = "Spring10_PtResolution_AK5PF.txt";
bool doGaussianResol = false;
// ptResol = new JetResolution(fileResolName, doGaussianResol);
leptonRelIsoQCDCutUpper = 0.9, leptonRelIsoQCDCutLower = 0.2;
topMassMeas = 172.9;
InitializeTurnOnReWeight("CentralJet30BTagIP_2ndSF_mu.root");
// LHAPDF::initPDFSet(1, "cteq66.LHgrid");
LHAPDF::initPDFSet(1, "CT10.LHgrid");
LHAPDF::initPDFSet(2, "MSTW2008nlo68cl.LHgrid");
//LHAPDF::initPDFSet(3, "MSTW2008nlo68cl.LHgrid");
// LHAPDF::initPDFSet(3, "NNPDF21_100.LHgrid");
// LHAPDF::initPDFSet(4, "HERAPDF01.LHgrid");
// LHAPDF::initPDFSet(4, "GJR08VFnloB.LHgrid");
//LHAPDF::initPDFSet(5, "GJR08FFnloE.LHgrid");
//LHAPDF::initPDFSet(6, "GJR08FFdis.LHgrid");
//LHAPDF::initPDFSet(3, "HERAPDF01.LHgrid");
// //LHAPDF::initPDFSet(7, "Alekhin_100.LHgrid");
// //cout<< "I work for now but I do nothing. But again, if you gotta do nothing, you better do it right. To prove my good will I will provide you with somse numbers later."<<endl;
isFirstEvent = true;
}
void SingleTopSystematicsTreesDumper::initBranchVars()
{
#define INT_NAN 9999
#define FLOAT_NAN 9999.0
#define DOUBLE_NAN 9999.0
//ints
chargeTree = INT_NAN;
runTree = INT_NAN;
lumiTree = INT_NAN;
eventTree = INT_NAN;
eventFlavourTree = INT_NAN;
firstJetFlavourTree = INT_NAN;
secondJetFlavourTree = INT_NAN;
thirdJetFlavourTree = INT_NAN;
nJ = INT_NAN;
nJNoPU = INT_NAN;
nJCentral = INT_NAN;
nJCentralNoPU = INT_NAN;
nJForward = INT_NAN;
nJForwardNoPU = INT_NAN;
nVertices = INT_NAN;
npv = INT_NAN;
ntchpt_tags = INT_NAN;
ncsvt_tags = INT_NAN;
ncsvm_tags = INT_NAN;
//doubles
weightTree = DOUBLE_NAN;
w1TCHPT = DOUBLE_NAN;
w2TCHPT = DOUBLE_NAN;
w1CSVT = DOUBLE_NAN;
w2CSVT = DOUBLE_NAN;
w1CSVM = DOUBLE_NAN;
w2CSVM = DOUBLE_NAN;
PUWeightTree = DOUBLE_NAN;
turnOnWeightTree = DOUBLE_NAN;
turnOnReWeightTree = DOUBLE_NAN;
lepPt = DOUBLE_NAN;
lepEta = DOUBLE_NAN;
lepPhi = DOUBLE_NAN;
lepDeltaCorrectedRelIso = DOUBLE_NAN;
lepRhoCorrectedRelIso = DOUBLE_NAN;
lepEff = DOUBLE_NAN;
mtwMassTree = DOUBLE_NAN;
metPt = DOUBLE_NAN;
firstJetPt = DOUBLE_NAN;
firstJetEta = DOUBLE_NAN;
firstJetPhi = DOUBLE_NAN;
firstJetE = DOUBLE_NAN;
secondJetPt = DOUBLE_NAN;
secondJetEta = DOUBLE_NAN;
secondJetPhi = DOUBLE_NAN;
secondJetE = DOUBLE_NAN;
thirdJetPt = DOUBLE_NAN;
thirdJetEta = DOUBLE_NAN;
thirdJetPhi = DOUBLE_NAN;
thirdJetE = DOUBLE_NAN;
bJetPt = DOUBLE_NAN;
fJetPt = DOUBLE_NAN;
bJetEta = DOUBLE_NAN;
fJetEta = DOUBLE_NAN;
fJetPUID = DOUBLE_NAN;
fJetPUWP = DOUBLE_NAN;
//58 lines
etaTree = DOUBLE_NAN;
cosTree = DOUBLE_NAN;
cosBLTree = DOUBLE_NAN;
mtwMassTree = DOUBLE_NAN;
chargeTree = INT_NAN;
runTree = INT_NAN;
lumiTree = INT_NAN;
eventTree = INT_NAN;
weightTree = DOUBLE_NAN;
fJetFlavourTree = INT_NAN;
bJetFlavourTree = INT_NAN;
eventFlavourTree = INT_NAN;
nVertices = INT_NAN;
npv = INT_NAN;
firstJetFlavourTree = INT_NAN;
secondJetFlavourTree = INT_NAN;
thirdJetFlavourTree = INT_NAN;
bWeightTreeBTagUp = DOUBLE_NAN;
bWeightTreeBTagDown = DOUBLE_NAN;
bWeightTreeMisTagUp = DOUBLE_NAN;
bWeightTreeMisTagDown = DOUBLE_NAN;
PUWeightTree = DOUBLE_NAN;
PUWeightTreePUUp = DOUBLE_NAN;
PUWeightTreePUDown = DOUBLE_NAN;
turnOnWeightTree = DOUBLE_NAN;
turnOnReWeightTree = DOUBLE_NAN;
turnOnWeightTreeJetTrig1Up = DOUBLE_NAN;
turnOnWeightTreeJetTrig1Down = DOUBLE_NAN;
turnOnWeightTreeJetTrig2Up = DOUBLE_NAN;
turnOnWeightTreeJetTrig2Down = DOUBLE_NAN;
turnOnWeightTreeJetTrig3Up = DOUBLE_NAN;
turnOnWeightTreeJetTrig3Down = DOUBLE_NAN;
turnOnWeightTreeBTagTrig1Up = DOUBLE_NAN;
turnOnWeightTreeBTagTrig1Down = DOUBLE_NAN;
turnOnWeightTreeBTagTrig2Up = DOUBLE_NAN;
turnOnWeightTreeBTagTrig2Down = DOUBLE_NAN;
turnOnWeightTreeBTagTrig3Up = DOUBLE_NAN;
turnOnWeightTreeBTagTrig3Down = DOUBLE_NAN;
lepPt = DOUBLE_NAN;
lepEta = DOUBLE_NAN;
lepPhi = DOUBLE_NAN;
lepDeltaCorrectedRelIso = DOUBLE_NAN;
lepRhoCorrectedRelIso = DOUBLE_NAN;
lepEff = DOUBLE_NAN;
lepEffB = DOUBLE_NAN;
fJetPt = DOUBLE_NAN;
fJetE = DOUBLE_NAN;
fJetEta = DOUBLE_NAN;
fJetPhi = DOUBLE_NAN;
fJetBTag = DOUBLE_NAN;
fJetPUID = DOUBLE_NAN;
fJetPUWP = DOUBLE_NAN;
bJetPt = DOUBLE_NAN;
bJetE = DOUBLE_NAN;
bJetEta = DOUBLE_NAN;
bJetPhi = DOUBLE_NAN;
bJetBTag = DOUBLE_NAN;
bJetPUID = DOUBLE_NAN;
bJetPUWP = DOUBLE_NAN;
firstJetPt = DOUBLE_NAN;
firstJetEta = DOUBLE_NAN;
firstJetPhi = DOUBLE_NAN;
firstJetE = DOUBLE_NAN;
secondJetPt = DOUBLE_NAN;
secondJetEta = DOUBLE_NAN;
secondJetPhi = DOUBLE_NAN;
secondJetE = DOUBLE_NAN;
thirdJetPt = DOUBLE_NAN;
thirdJetEta = DOUBLE_NAN;
thirdJetPhi = DOUBLE_NAN;
thirdJetE = DOUBLE_NAN;
metPt = DOUBLE_NAN;
metPhi = DOUBLE_NAN;
topMassTree = DOUBLE_NAN;
topMtwTree = DOUBLE_NAN;
topPt = DOUBLE_NAN;
topPhi = DOUBLE_NAN;
topEta = DOUBLE_NAN;
topE = DOUBLE_NAN;
electronID = DOUBLE_NAN;
totalEnergy = DOUBLE_NAN;
totalMomentum = DOUBLE_NAN;
lowBTagTree = DOUBLE_NAN;
highBTagTree = DOUBLE_NAN;
pdf_weights_mstw =FLOAT_NAN;
pdf_weights_nnpdf21=FLOAT_NAN;
pdf_weights_gjr_ff=FLOAT_NAN;
pdf_weights_gjr_fv=FLOAT_NAN;
pdf_weights_gjr_fdis=FLOAT_NAN;
pdf_weights_alekhin=FLOAT_NAN;
for (int i = 0; i < 52; i++)
{
pdf_weights[i] = FLOAT_NAN;
}
}
void SingleTopSystematicsTreesDumper::analyze(const Event &iEvent, const EventSetup &iSetup)
{
initBranchVars();
//cout <<" test 1 "<<endl;
iEvent.getByLabel(jetsEta_, jetsEta);
iEvent.getByLabel(jetsPt_, jetsPt);
// if(jetsPt->size() < 2)return;
// if (jetsPt->size() > 22 )return; //Crazy events with huge jet multiplicity in mc
//if (jetsPt->size() > 20 && channel != "Data")return; //Crazy events with huge jet multiplicity in mc
iEvent.getByLabel(jetsPhi_, jetsPhi);
if (isFirstEvent && takeBTagSFFromDB_)
{
//cout << "isfirst " << endl;
iSetup.get<BTagPerformanceRecord>().get("MISTAGTCHPT", perfMHP);
iSetup.get<BTagPerformanceRecord>().get("MISTAGTCHPM", perfMHPM);
iSetup.get<BTagPerformanceRecord>().get("MISTAGTCHEL", perfMHE);
iSetup.get<BTagPerformanceRecord>().get("BTAGTCHPM", perfBHPM);
iSetup.get<BTagPerformanceRecord>().get("BTAGTCHPT", perfBHP);
iSetup.get<BTagPerformanceRecord>().get("BTAGTCHEL", perfBHE);
isFirstEvent = false;
}
gotLeptons = 0;
gotPV = 0;
gotQCDLeptons = 0;
gotLooseLeptons = 0;
gotJets = 0;
gotAllJets = 0;
gotMets = 0;
gotPU = 0;
gotPDFs = 0;
jsfshpt.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfshpt_b_tag_up.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfshpt_b_tag_down.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfshpt_mis_tag_up.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfshpt_mis_tag_down.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvt.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvt_b_tag_up.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvt_b_tag_down.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvt_mis_tag_up.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvt_mis_tag_down.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvm.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvm_b_tag_up.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvm_b_tag_down.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvm_mis_tag_up.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvm_mis_tag_down.clear();// bjs.clear();cjs.clear();ljs.clear();
iEvent.getByLabel(METPhi_, METPhi);
iEvent.getByLabel(METPt_, METPt);
iEvent.getByLabel(leptonsDeltaCorrectedRelIso_, leptonsDeltaCorrectedRelIso);
double PUWeight = 1;
double PUWeightNoSyst = 1;
double bWeightNoSyst = 1;
double turnOnWeightValueNoSyst = 1;
double turnOnReWeightTreeNoSyst = 1;
BinningPointByMap measurePoint;
float metPx = 0;
float metPy = 0;
metPx = METPt->at(0) * cos(METPhi->at(0));
metPy = METPt->at(0) * sin(METPhi->at(0));
float metPxTmp = metPx;
float metPyTmp = metPy;
size_t nLeptons = 0;//leptonsPt->size();
size_t nQCDLeptons = 0;//leptonsPt->size();
size_t nJets = 0;
size_t nJetsNoPU = 0;
size_t nJetsCentralNoPU = 0;
size_t nJetsCentral = 0;
size_t nJetsForwardNoPU = 0;
size_t nJetsForward = 0;
size_t nJetsNoSyst = 0;
size_t nBJets = 0;
size_t nLooseBJets = 0;
double WeightLumi = finalLumi * crossSection / originalEvents;
double Weight = 1;
double MTWValue = 0;
double MTWValueQCD = 0;
double RelIsoQCDCut = 0.1;
float ptCut = 40;
double myWeight = 1.;
bool didLeptonLoop = false;
bool passesLeptonStep = false;
bool isQCD = false;
bool didJetLoop = false;
if (channel == "Data")WeightLumi = 1;
int secondPtPosition = -1;
int thirdPtPosition = -1;
double secondPt = -1;
double thirdPt = -1;
int lowBTagTreePositionNoSyst = -1;
int highBTagTreePositionNoSyst = -1;
int maxPtTreePositionNoSyst = -1;
int minPtTreePositionNoSyst = -1;
for (size_t s = 0; s < systematics.size(); ++s)
{
string syst_name = systematics.at(s);
string syst = syst_name;
nLeptons = 0;
nQCDLeptons = 0;
nJets = 0;
nJetsNoPU = 0;
nJetsCentral = 0;
nJetsCentralNoPU = 0;
nJetsForward = 0;
nJetsForwardNoPU = 0;
Weight = WeightLumi;
HT = 0;
bool is_btag_relevant = ((syst_name == "noSyst" || syst_name == "BTagUp" || syst_name == "BTagDown"
|| syst_name == "MisTagUp" || syst_name == "MisTagDown"
|| syst_name == "JESUp" || syst_name == "JESDown"
|| syst_name == "JERUp" || syst_name == "JERDown"
) && channel != "Data"
);
if( syst == "noSyst" && doMCTruth_ && doFullMCTruth_){
iEvent.getByLabel(MCTopQuarksEta_, MCTopQuarksEta); iEvent.getByLabel(MCTopQuarksPt_, MCTopQuarksPt); iEvent.getByLabel(MCTopQuarksPhi_, MCTopQuarksPhi); iEvent.getByLabel(MCTopQuarksEnergy_, MCTopQuarksEnergy); iEvent.getByLabel(MCTopQuarksMotherId_, MCTopQuarksMotherId);
iEvent.getByLabel(MCTopQuarkBarsEta_, MCTopQuarkBarsEta); iEvent.getByLabel(MCTopQuarkBarsPt_, MCTopQuarkBarsPt); iEvent.getByLabel(MCTopQuarkBarsPhi_, MCTopQuarkBarsPhi); iEvent.getByLabel(MCTopQuarkBarsEnergy_, MCTopQuarkBarsEnergy); iEvent.getByLabel(MCTopQuarkBarsMotherId_, MCTopQuarkBarsMotherId);
iEvent.getByLabel(MCTopLeptonsEta_, MCTopLeptonsEta); iEvent.getByLabel(MCTopLeptonsPt_, MCTopLeptonsPt); iEvent.getByLabel(MCTopLeptonsPhi_, MCTopLeptonsPhi); iEvent.getByLabel(MCTopLeptonsEnergy_, MCTopLeptonsEnergy); iEvent.getByLabel(MCTopLeptonsMotherId_, MCTopLeptonsMotherId);
iEvent.getByLabel(MCTopNeutrinosEta_, MCTopNeutrinosEta); iEvent.getByLabel(MCTopNeutrinosPt_, MCTopNeutrinosPt); iEvent.getByLabel(MCTopNeutrinosPhi_, MCTopNeutrinosPhi); iEvent.getByLabel(MCTopNeutrinosEnergy_, MCTopNeutrinosEnergy); iEvent.getByLabel(MCTopNeutrinosMotherId_, MCTopNeutrinosMotherId);
iEvent.getByLabel(MCTopBQuarksEta_, MCTopBQuarksEta); iEvent.getByLabel(MCTopBQuarksPt_, MCTopBQuarksPt); iEvent.getByLabel(MCTopBQuarksPhi_, MCTopBQuarksPhi); iEvent.getByLabel(MCTopBQuarksEnergy_, MCTopBQuarksEnergy); iEvent.getByLabel(MCTopBQuarksMotherId_, MCTopBQuarksMotherId);
iEvent.getByLabel(MCTopWsEta_, MCTopWsEta); iEvent.getByLabel(MCTopWsPt_, MCTopWsPt); iEvent.getByLabel(MCTopWsPhi_, MCTopWsPhi); iEvent.getByLabel(MCTopWsEnergy_, MCTopWsEnergy); iEvent.getByLabel(MCTopWsDauOneId_, MCTopWsDauOneId);
iEvent.getByLabel(MCLeptonsEta_, MCLeptonsEta); iEvent.getByLabel(MCLeptonsPt_, MCLeptonsPt); iEvent.getByLabel(MCLeptonsPhi_, MCLeptonsPhi); iEvent.getByLabel(MCLeptonsEnergy_, MCLeptonsEnergy);
iEvent.getByLabel(MCNeutrinosEta_, MCNeutrinosEta); iEvent.getByLabel(MCNeutrinosPt_, MCNeutrinosPt); iEvent.getByLabel(MCNeutrinosPhi_, MCNeutrinosPhi); iEvent.getByLabel(MCNeutrinosEnergy_, MCNeutrinosEnergy);
iEvent.getByLabel(MCBQuarksEta_, MCBQuarksEta); iEvent.getByLabel(MCBQuarksPt_, MCBQuarksPt); iEvent.getByLabel(MCBQuarksPhi_, MCBQuarksPhi); iEvent.getByLabel(MCBQuarksEnergy_, MCBQuarksEnergy);
iEvent.getByLabel(MCQuarksEta_, MCQuarksEta); iEvent.getByLabel(MCQuarksPt_, MCQuarksPt); iEvent.getByLabel(MCQuarksPhi_, MCQuarksPhi); iEvent.getByLabel(MCQuarksEnergy_, MCQuarksEnergy);
iEvent.getByLabel(MCTopBQuarksPdgId_, MCTopBQuarksPdgId);iEvent.getByLabel(MCTopWsPdgId_, MCTopWsPdgId);
iEvent.getByLabel(MCTopQuarksPdgId_, MCTopQuarksPdgId);iEvent.getByLabel(MCTopsPdgId_, MCTopsPdgId);
iEvent.getByLabel(MCTopQuarkBarsPdgId_, MCTopQuarkBarsPdgId);
iEvent.getByLabel(MCTopLeptonsPdgId_, MCTopLeptonsPdgId);
iEvent.getByLabel(MCTopNeutrinosPdgId_, MCTopNeutrinosPdgId);
iEvent.getByLabel(MCBQuarksPdgId_, MCBQuarksPdgId); iEvent.getByLabel(MCQuarksPdgId_, MCQuarksPdgId);
iEvent.getByLabel(MCLeptonsPdgId_, MCLeptonsPdgId); iEvent.getByLabel(MCNeutrinosPdgId_, MCNeutrinosPdgId);
iEvent.getByLabel(MCBQuarksMotherId_, MCBQuarksMotherId); iEvent.getByLabel(MCQuarksMotherId_, MCQuarksMotherId);
iEvent.getByLabel(MCLeptonsMotherId_, MCLeptonsMotherId); iEvent.getByLabel(MCNeutrinosMotherId_, MCNeutrinosMotherId);
for (size_t p = 1; p <= 12; ++p){
if(!(MCQuarksEta->size() < p) ){
MCQuarksEtaVec[p-1]=MCQuarksEta->at(p-1);
MCQuarksPhiVec[p-1]=MCQuarksPhi->at(p-1);
MCQuarksPtVec[p-1]=MCQuarksPt->at(p-1);
MCQuarksEnergyVec[p-1]=MCQuarksEnergy->at(p-1);
MCQuarksPdgIdVec[p-1]=MCQuarksPdgId->at(p-1);
MCQuarksMotherIdVec[p-1]=MCQuarksMotherId->at(p-1);
}
else{
MCQuarksEtaVec[p-1]=-999;
MCQuarksPhiVec[p-1]=-999;
MCQuarksPtVec[p-1]=-999;
MCQuarksEnergyVec[p-1]=-999;
MCQuarksPdgIdVec[p-1]=-999;
MCQuarksMotherIdVec[p-1]=-999;
}
}
for (size_t p = 1; p <= 4; ++p){
if(!(MCLeptonsEta->size() < p) ){
MCLeptonsEtaVec[p-1]=MCLeptonsEta->at(p-1);
MCLeptonsPhiVec[p-1]=MCLeptonsPhi->at(p-1);
MCLeptonsPtVec[p-1]=MCLeptonsPt->at(p-1);
MCLeptonsEnergyVec[p-1]=MCLeptonsEnergy->at(p-1);
MCLeptonsPdgIdVec[p-1]=MCLeptonsPdgId->at(p-1);
MCLeptonsMotherIdVec[p-1]=MCLeptonsMotherId->at(p-1);
}
else{
MCLeptonsEtaVec[p-1]=-999;
MCLeptonsPhiVec[p-1]=-999;
MCLeptonsPtVec[p-1]=-999;
MCLeptonsEnergyVec[p-1]=-999;
MCLeptonsPdgIdVec[p-1]=-999;
MCLeptonsMotherIdVec[p-1]=-999;
}
if(!(MCBQuarksEta->size() < p) ){
MCBQuarksEtaVec[p-1]=MCBQuarksEta->at(p-1);
MCBQuarksPhiVec[p-1]=MCBQuarksPhi->at(p-1);
MCBQuarksPtVec[p-1]=MCBQuarksPt->at(p-1);
MCBQuarksEnergyVec[p-1]=MCBQuarksEnergy->at(p-1);
MCBQuarksPdgIdVec[p-1]=MCBQuarksPdgId->at(p-1);
MCBQuarksMotherIdVec[p-1]=MCBQuarksMotherId->at(p-1);
}
else{
MCBQuarksEtaVec[p-1]=-999;
MCBQuarksPhiVec[p-1]=-999;
MCBQuarksPtVec[p-1]=-999;
MCBQuarksEnergyVec[p-1]=-999;
MCBQuarksPdgIdVec[p-1]=-999;
MCBQuarksMotherIdVec[p-1]=-999;
}
if(!(MCNeutrinosEta->size() < p) ){
MCNeutrinosEtaVec[p-1]=MCNeutrinosEta->at(p-1);
MCNeutrinosPhiVec[p-1]=MCNeutrinosPhi->at(p-1);
MCNeutrinosPtVec[p-1]=MCNeutrinosPt->at(p-1);
MCNeutrinosEnergyVec[p-1]=MCNeutrinosEnergy->at(p-1);
MCNeutrinosPdgIdVec[p-1]=MCNeutrinosPdgId->at(p-1);
MCNeutrinosMotherIdVec[p-1]=MCNeutrinosMotherId->at(p-1);
}
else{
MCNeutrinosEtaVec[p-1]=-999;
MCNeutrinosPhiVec[p-1]=-999;
MCNeutrinosPtVec[p-1]=-999;
MCNeutrinosEnergyVec[p-1]=-999;
MCNeutrinosPdgIdVec[p-1]=-999;
MCNeutrinosMotherIdVec[p-1]=-999;
}
}
nMCTruthLeptons = 0;
for (size_t p = 1; p <= 2; ++p){
bool isLeptonic = false;
bool isHadronic = false;
size_t position = 0;
if(isSingleTopCompHEP_){
if (MCTopLeptonsEta->size() < p)continue;
position = p;
MCTopLeptonsEtaVec[p-1]=MCTopLeptonsEta->at(position-1);
MCTopLeptonsPhiVec[p-1]=MCTopLeptonsPhi->at(position-1);
MCTopLeptonsPtVec[p-1]=MCTopLeptonsPt->at(position-1);
MCTopLeptonsEnergyVec[p-1]=MCTopLeptonsEnergy->at(position-1);
MCTopLeptonsPdgIdVec[p-1]=MCTopLeptonsPdgId->at(position-1);
MCTopLeptonsMotherIdVec[p-1]=MCTopLeptonsMotherId->at(position-1);
MCTopNeutrinosEtaVec[p-1]=MCTopNeutrinosEta->at(position-1);
MCTopNeutrinosPhiVec[p-1]=MCTopNeutrinosPhi->at(position-1);
MCTopNeutrinosPtVec[p-1]=MCTopNeutrinosPt->at(position-1);
MCTopNeutrinosEnergyVec[p-1]=MCTopNeutrinosEnergy->at(position-1);
MCTopNeutrinosPdgIdVec[p-1]=MCTopNeutrinosPdgId->at(position-1);
MCTopNeutrinosMotherIdVec[p-1]=MCTopNeutrinosMotherId->at(position-1);
if(!(MCTopBQuarksEta->size() < p) ){
MCTopBQuarksEtaVec[p-1]=MCTopBQuarksEta->at(p-1);
MCTopBQuarksPhiVec[p-1]=MCTopBQuarksPhi->at(p-1);
MCTopBQuarksPtVec[p-1]=MCTopBQuarksPt->at(p-1);
MCTopBQuarksEnergyVec[p-1]=MCTopBQuarksEnergy->at(p-1);
MCTopBQuarksPdgIdVec[p-1]=MCTopBQuarksPdgId->at(p-1);
MCTopBQuarksMotherIdVec[p-1]=MCTopBQuarksMotherId->at(p-1);
}
}
else{
if (MCTopWsEta->size() < p)continue;
if(MCTopNeutrinosEta->size()!=MCTopLeptonsEta->size())continue;
if(MCTopQuarksEta->size()!=MCTopQuarkBarsEta->size())continue;
for (size_t l = 1; l <= MCTopQuarksEta->size();++l ){
cout << " quark id "<< MCTopQuarksPdgId->at(l-1) << " quarkbar id "<< MCTopQuarkBarsPdgId->at(l-1) <<
" W dau one id "<< MCTopWsDauOneId->at(p-1) << endl;
cout << " quark mother id "<< MCTopQuarksMotherId->at(l-1) << " quarkbar id "<< MCTopQuarkBarsMotherId->at(l-1) <<
" W id "<< MCTopWsPdgId->at(p-1) << endl;
if( MCTopQuarksPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) || MCTopQuarkBarsPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) ){
position = l;
isHadronic = true;
}
}
for (size_t l = 1; l <= MCTopLeptonsEta->size();++l ){
cout << " lepton id "<< MCTopLeptonsPdgId->at(l-1) << " neutrino id "<< MCTopNeutrinosPdgId->at(l-1)<<
" W dau one id "<< MCTopWsDauOneId->at(p-1) << endl;
cout << " lepton mother id "<< MCTopLeptonsMotherId->at(l-1) << " neutrino id "<< MCTopNeutrinosMotherId->at(l-1) <<
" W id "<< MCTopWsPdgId->at(p-1) << endl;
if( MCTopLeptonsPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) || MCTopNeutrinosPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) ){
position = l;
++nMCTruthLeptons;
isLeptonic = true;
}
}
cout <<" pos "<< position <<" islep "<< isLeptonic<< " lep size "<< MCTopLeptonsEta->size()<< " neu size "<< MCTopNeutrinosEta->size()<< endl;
cout <<" pos "<< position <<" ishad "<< isHadronic<< " quark size"<< MCTopQuarksEta->size()<< " qbar size "<< MCTopQuarkBarsEta->size()<< endl;
if(isLeptonic){
MCTopLeptonsEtaVec[p-1]=MCTopLeptonsEta->at(position-1);
MCTopLeptonsPhiVec[p-1]=MCTopLeptonsPhi->at(position-1);
MCTopLeptonsPtVec[p-1]=MCTopLeptonsPt->at(position-1);
MCTopLeptonsEnergyVec[p-1]=MCTopLeptonsEnergy->at(position-1);
MCTopLeptonsPdgIdVec[p-1]=MCTopLeptonsPdgId->at(position-1);
MCTopLeptonsMotherIdVec[p-1]=MCTopLeptonsMotherId->at(position-1);
MCTopNeutrinosEtaVec[p-1]=MCTopNeutrinosEta->at(position-1);
MCTopNeutrinosPhiVec[p-1]=MCTopNeutrinosPhi->at(position-1);
MCTopNeutrinosPtVec[p-1]=MCTopNeutrinosPt->at(position-1);
MCTopNeutrinosEnergyVec[p-1]=MCTopNeutrinosEnergy->at(position-1);
MCTopNeutrinosPdgIdVec[p-1]=MCTopNeutrinosPdgId->at(position-1);
MCTopNeutrinosMotherIdVec[p-1]=MCTopNeutrinosMotherId->at(position-1);
}
else{
MCTopLeptonsEtaVec[p-1]=-999;
MCTopLeptonsPhiVec[p-1]=-999;
MCTopLeptonsPtVec[p-1]=-999;
MCTopLeptonsEnergyVec[p-1]=-999;
MCTopLeptonsPdgIdVec[p-1]=-999;
MCTopLeptonsMotherIdVec[p-1]=-999;
MCTopNeutrinosEtaVec[p-1]=-999;
MCTopNeutrinosPhiVec[p-1]=-999;
MCTopNeutrinosPtVec[p-1]=-999;
MCTopNeutrinosEnergyVec[p-1]=-999;
MCTopNeutrinosPdgIdVec[p-1]=-999;
MCTopNeutrinosMotherIdVec[p-1]=-999;
}
if(isHadronic){
MCTopQuarksEtaVec[p-1]=MCTopQuarksEta->at(position-1);
MCTopQuarksPhiVec[p-1]=MCTopQuarksPhi->at(position-1);
MCTopQuarksPtVec[p-1]=MCTopQuarksPt->at(position-1);
MCTopQuarksEnergyVec[p-1]=MCTopQuarksEnergy->at(position-1);
MCTopQuarksPdgIdVec[p-1]=MCTopQuarksPdgId->at(position-1);
MCTopQuarksMotherIdVec[p-1]=MCTopQuarksMotherId->at(position-1);
MCTopQuarkBarsEtaVec[p-1]=MCTopQuarkBarsEta->at(position-1);
MCTopQuarkBarsPhiVec[p-1]=MCTopQuarkBarsPhi->at(position-1);
MCTopQuarkBarsPtVec[p-1]=MCTopQuarkBarsPt->at(position-1);
MCTopQuarkBarsEnergyVec[p-1]=MCTopQuarkBarsEnergy->at(position-1);
MCTopQuarkBarsPdgIdVec[p-1]=MCTopQuarkBarsPdgId->at(position-1);
MCTopQuarkBarsMotherIdVec[p-1]=MCTopQuarkBarsMotherId->at(position-1);
}
else{
MCTopQuarksEtaVec[p-1]=-999;
MCTopQuarksPhiVec[p-1]=-999;
MCTopQuarksPtVec[p-1]=-999;
MCTopQuarksEnergyVec[p-1]=-999;
MCTopQuarksPdgIdVec[p-1]=-999;
MCTopQuarksMotherIdVec[p-1]=-999;
MCTopQuarkBarsEtaVec[p-1]=-999;
MCTopQuarkBarsPhiVec[p-1]=-999;
MCTopQuarkBarsPtVec[p-1]=-999;
MCTopQuarkBarsEnergyVec[p-1]=-999;
MCTopQuarkBarsPdgIdVec[p-1]=-999;
MCTopQuarkBarsMotherIdVec[p-1]=-999;
}
if(!(MCTopWsEta->size() < p) ){
MCTopWsEtaVec[p-1]=MCTopWsEta->at(p-1);
MCTopWsPhiVec[p-1]=MCTopWsPhi->at(p-1);
MCTopWsPtVec[p-1]=MCTopWsPt->at(p-1);
MCTopWsEnergyVec[p-1]=MCTopWsEnergy->at(p-1);
MCTopWsPdgIdVec[p-1]=MCTopWsPdgId->at(p-1);
}
else{
MCTopWsEtaVec[p-1]=-999;
MCTopWsPhiVec[p-1]=-999;
MCTopWsPtVec[p-1]=-999;
MCTopWsEnergyVec[p-1]=-999;
MCTopWsPdgIdVec[p-1]=-999;
}
if(!(MCTopBQuarksEta->size() < p) ){
MCTopBQuarksEtaVec[p-1]=MCTopBQuarksEta->at(p-1);
MCTopBQuarksPhiVec[p-1]=MCTopBQuarksPhi->at(p-1);
MCTopBQuarksPtVec[p-1]=MCTopBQuarksPt->at(p-1);
MCTopBQuarksEnergyVec[p-1]=MCTopBQuarksEnergy->at(p-1);
MCTopBQuarksPdgIdVec[p-1]=MCTopBQuarksPdgId->at(p-1);
MCTopBQuarksMotherIdVec[p-1]=MCTopBQuarksMotherId->at(p-1);
}
else{
MCTopBQuarksEtaVec[p-1]=-999;
MCTopBQuarksPhiVec[p-1]=-999;
MCTopBQuarksPtVec[p-1]=-999;
MCTopBQuarksEnergyVec[p-1]=-999;
MCTopBQuarksPdgIdVec[p-1]=-999;
MCTopBQuarksMotherIdVec[p-1]=-999;
}
if( (!(MCBQuarksEta->size() < p)) && (!(MCTopWsEta->size() < p))){
math::PtEtaPhiELorentzVector mctop = math::PtEtaPhiELorentzVector(
(MCTopBQuarksPtVec[p-1]+MCTopWsPtVec[p-1]),
(MCTopBQuarksEtaVec[p-1]+MCTopWsEtaVec[p-1]),
(MCTopBQuarksPhiVec[p-1]+MCTopWsPhiVec[p-1]),
(MCTopBQuarksEnergyVec[p-1]+MCTopWsEnergyVec[p-1]) );
MCTopsPtVec[p-1]=mctop.pt();
MCTopsEtaVec[p-1]=mctop.eta();
MCTopsPhiVec[p-1]=mctop.phi();
MCTopsEnergyVec[p-1]=mctop.energy();
MCTopsPdgIdVec[p-1]=6* MCTopBQuarksPdgIdVec[p-1]/5.;
}
else{
MCTopsEtaVec[p-1]=-999;
MCTopsPhiVec[p-1]=-999;
MCTopsPtVec[p-1]=-999;
MCTopsEnergyVec[p-1]=-999;
MCTopsPdgIdVec[p-1]=-999;
}
}
}
treesMCTruth->Fill();
}
//Setup for systematics
//This is done according to old b-tagging prescriptions
//Here we have vectors of weights
//to be associated with the
//b-jets selection in the sample according to algorythm X:
//a b-tag requirement implies a b_weight_tag_algoX,
//a b-veto requirement implies a b_weight_antitag_algoX
//TCHPT
b_weight_tchpt_1_tag = 1;
b_weight_tchpt_0_tags = 1;
b_weight_tchpt_2_tags = 1;
//CSVT
b_weight_csvm_1_tag = 1;
b_weight_csvm_0_tags = 1;
b_weight_csvm_2_tags = 1;
//CSVT
b_weight_csvt_1_tag = 1;
b_weight_csvt_0_tags = 1;
b_weight_csvt_2_tags = 1;
nb = 0;
nc = 0;
nudsg = 0;
//Clear the vector of objects to be used in the selection
//Define - initialize some variables
MTWValue = 0;
//position of lowest and highest b-tag used to chose the top candidate
int lowBTagTreePosition = -1;
lowBTagTree = 99999;
int highBTagTreePosition = -1;
highBTagTree = -9999;
int maxPtTreePosition = -1;
maxPtTree = -99999;
int minPtTreePosition = -1;
minPtTree = 99999;
secondPt = -1;
thirdPt = -1;
secondPtPosition = -1;
thirdPtPosition = -1;
//Taking the unclustered met previously evaluated
//and already present in the n-tuples
//This is used for syst up and down
if (syst_name == "UnclusteredMETUp")
{
iEvent.getByLabel(UnclMETPx_, UnclMETPx);
iEvent.getByLabel(UnclMETPy_, UnclMETPy);
metPx += (*UnclMETPx) * 0.1;
metPy += (*UnclMETPy) * 0.1;
}
if (syst_name == "UnclusteredMETDown")
{
iEvent.getByLabel(UnclMETPx_, UnclMETPx);
iEvent.getByLabel(UnclMETPy_, UnclMETPy);
metPx -= (*UnclMETPx) * 0.1;
metPy -= (*UnclMETPy) * 0.1;
}
//Define - initialize some variables
float eta;
float ptCorr;
int flavour;
double unc = 0;
//Loops to apply systematics on jets-leptons
//cout << " before leptons "<<endl;
//Lepton loop
if (!didLeptonLoop)
{
for (size_t i = 0; i < leptonsDeltaCorrectedRelIso->size(); ++i)
{
float leptonRelIsoDeltaCorr = 9999.,leptonRelIsoRhoCorr=9999.;
float leptonMVAIDTemp = -1.1,leptonNHitsTemp=10.;
if (leptonsFlavour_ == "muon")
{
leptonRelIsoDeltaCorr = leptonsDeltaCorrectedRelIso->at(i);
if (leptonRelIsoDeltaCorr > RelIsoCut)continue;
}
if (leptonsFlavour_ == "electron")
{
iEvent.getByLabel(leptonsRhoCorrectedRelIso_, leptonsRhoCorrectedRelIso);
leptonRelIsoRhoCorr = leptonsRhoCorrectedRelIso->at(i);
if (leptonRelIsoRhoCorr > RelIsoCut)continue;
// cout << " inside lepton loop: lepton n "<< i +1 << " reliso " << leptonsRhoCorrectedRelIso->at(i) <<" nLeptons before: "<<nLeptons<<endl;
}
float leptonPt = 0.;
// cout << "lep " << i <<endl;
iEvent.getByLabel(leptonsPt_, leptonsPt);
leptonPt = leptonsPt->at(i)*1.;
if ( leptonPt < 26.) continue;
//Apply isolation cut
if (!gotLeptons)
{
if (leptonsFlavour_ == "muon")
{
iEvent.getByLabel(leptonsRhoCorrectedRelIso_, leptonsRhoCorrectedRelIso);
lepRhoCorrectedRelIso = leptonsRhoCorrectedRelIso->at(i);
}
iEvent.getByLabel(leptonsEta_, leptonsEta);
iEvent.getByLabel(leptonsPhi_, leptonsPhi);
iEvent.getByLabel(leptonsEnergy_, leptonsEnergy);
iEvent.getByLabel(leptonsCharge_, leptonsCharge);
iEvent.getByLabel(leptonsID_, leptonsID);
iEvent.getByLabel(leptonsDB_, leptonsDB);
gotLeptons = true;
}
//if electron apply ID cuts
if (leptonsFlavour_ == "electron" )
{
if (leptonsID->size() == 0)cout << "warning requiring ele id of collection which has no entries! Check the leptonsFlavour parameter " << endl;
float leptonRelIsoRhoCorr = leptonsRhoCorrectedRelIso->at(i);
lepRhoCorrectedRelIso = leptonRelIsoRhoCorr;
iEvent.getByLabel(leptonsMVAID_, leptonsMVAID);
iEvent.getByLabel(leptonsNHits_, leptonsNHits);
float leptonID = leptonsID->at(i);
leptonMVAIDTemp = leptonsMVAID->at(i);
leptonNHitsTemp = leptonsNHits->at(i);
electronID = leptonID;
if(useCutBasedID_>0){
if(!(leptonID>0.0))continue;
}
if(useMVAID_>0){
if(!(leptonMVAIDTemp>0.90))continue;
if(!(leptonNHitsTemp<=0.00001))continue;
}
}
if (leptonsFlavour_ == "muon" )
{
iEvent.getByLabel(leptonsDZ_, leptonsDZ);
if ( leptonsDZ->at(i) > 0.5) continue;
}
float leptonDB = leptonsDB->at(i);
if ( fabs(leptonDB) > 0.02) continue;
lepDeltaCorrectedRelIso = leptonRelIsoDeltaCorr;
lepRhoCorrectedRelIso = leptonRelIsoRhoCorr;
leptonMVAID = leptonMVAIDTemp;
leptonNHits = leptonNHitsTemp;
float leptonPhi = leptonsPhi->at(i);
float leptonEta = leptonsEta->at(i);
float leptonE = leptonsEnergy->at(i);
//Build the lepton 4-momentum
++nLeptons;
//if( lepRhoCorrectedRelIso > RelIsoCut )cout << " lepton n "<< nLeptons<< " syst "<<syst<< " " << lepRhoCorrectedRelIso<< " relisocut "<<RelIsoCut<< endl;
leptons[nLeptons - 1] = math::PtEtaPhiELorentzVector(leptonPt, leptonEta, leptonPhi, leptonE);
// Leptons.push_back(math::PtEtaPhiELorentzVector(leptonPt,leptonEta,leptonPhi,leptonE));
if (nLeptons >= 3) break;
// cout<< " lepton number " << nLeptons << " pt "<< leptonPt << " eta " << fabs(leptonEta)<< endl;
}
bool passesLeptons = (nLeptons == 1);
bool passesOneLepton = (nLeptons == 1);
if (passesLeptons)
{
if (passesLeptons && syst == "noSyst")++passingLepton;
iEvent.getByLabel(looseMuonsDeltaCorrectedRelIso_, looseMuonsDeltaCorrectedRelIso);
if (passesLeptons && syst == "noSyst" && looseMuonsDeltaCorrectedRelIso->size() == 1)++passingMuonVeto;
iEvent.getByLabel(looseElectronsDeltaCorrectedRelIso_, looseElectronsDeltaCorrectedRelIso);
bool passesLooseLeptons = (looseMuonsDeltaCorrectedRelIso->size() + looseElectronsDeltaCorrectedRelIso->size()) == 1;
passesLeptons = passesLeptons && passesLooseLeptons;
}
if (passesLeptons && syst == "noSyst")++passingLeptonVeto;
isQCD = (!passesLeptons);
//Loop for the qcd leptons
if (doQCD_ && isQCD)
{
iEvent.getByLabel(qcdLeptonsDeltaCorrectedRelIso_, qcdLeptonsDeltaCorrectedRelIso);
iEvent.getByLabel(qcdLeptonsRhoCorrectedRelIso_, qcdLeptonsRhoCorrectedRelIso);
cout << "qcd lep size" <<qcdLeptonsDeltaCorrectedRelIso->size()<<endl;
for (size_t i = 0; i < qcdLeptonsDeltaCorrectedRelIso->size(); ++i)
{
float leptonPt = 0.;
iEvent.getByLabel(qcdLeptonsPt_, qcdLeptonsPt);
leptonPt = qcdLeptonsPt->at(i);
if ( leptonPt < 26.) continue;
float leptonRelIso = qcdLeptonsDeltaCorrectedRelIso->at(i);
// cout << "qcd lep " << i << "rel iso "<<leptonRelIso<<endl;
float leptonQCDRelIso = leptonRelIso;
//Use an anti-isolation requirement
lepDeltaCorrectedRelIso = leptonRelIso;
lepRhoCorrectedRelIso = qcdLeptonsRhoCorrectedRelIso->at(i) ;
if (leptonsFlavour_ == "muon")
{
if ( leptonQCDRelIso > leptonRelIsoQCDCutUpper )continue;
if ( leptonQCDRelIso < leptonRelIsoQCDCutLower )continue;
if (!gotQCDLeptons)
{
iEvent.getByLabel(qcdLeptonsEta_, qcdLeptonsEta);
iEvent.getByLabel(qcdLeptonsPhi_, qcdLeptonsPhi);
iEvent.getByLabel(qcdLeptonsEnergy_, qcdLeptonsEnergy);
iEvent.getByLabel(qcdLeptonsCharge_, qcdLeptonsCharge);
iEvent.getByLabel(qcdLeptonsID_, qcdLeptonsID);
iEvent.getByLabel(qcdLeptonsDB_, qcdLeptonsDB);
gotQCDLeptons = true;
// cout << " qcd lep "<< endl;
}
}
if (leptonsFlavour_ == "electron" )
{
bool QCDCondition = false;
iEvent.getByLabel(qcdLeptonsID_, qcdLeptonsID);
iEvent.getByLabel(qcdLeptonsDB_, qcdLeptonsDB);
float leptonID = qcdLeptonsID->at(i);
float beamspot = abs(qcdLeptonsDB->at(i));
bool isid = (leptonID == 1 || leptonID == 3 || leptonID == 5 || leptonID == 7);
QCDCondition = (!(lepRhoCorrectedRelIso < 0.1) );
//if (!QCDCondition) continue;
electronID = leptonID;
if (!gotQCDLeptons)
{
iEvent.getByLabel(qcdLeptonsEta_, qcdLeptonsEta);
iEvent.getByLabel(qcdLeptonsPhi_, qcdLeptonsPhi);
iEvent.getByLabel(qcdLeptonsEnergy_, qcdLeptonsEnergy);
iEvent.getByLabel(qcdLeptonsCharge_, qcdLeptonsCharge);
gotQCDLeptons = true;
}
}
lepRelIso = leptonRelIso;
float qcdLeptonPt = qcdLeptonsPt->at(i);
float qcdLeptonPhi = qcdLeptonsPhi->at(i);
float qcdLeptonEta = qcdLeptonsEta->at(i);
float qcdLeptonE = qcdLeptonsEnergy->at(i);
//Create the lepton
++nQCDLeptons;
qcdLeptons[nQCDLeptons - 1] = math::PtEtaPhiELorentzVector(qcdLeptonPt, qcdLeptonEta, qcdLeptonPhi, qcdLeptonE);
// leptonsQCD.push_back(math::PtEtaPhiELorentzVector(leptonPt,leptonEta,leptonPhi,leptonE));
if (nQCDLeptons == 3) break;
}
}
didLeptonLoop = true;
isQCD = (nQCDLeptons == 1 && !passesLeptons);
passesLeptonStep = (passesLeptons || isQCD);
//cout << " nqcd lep "<<nQCDLeptons<< " passes leptons? " <<passesLeptons<<endl;
}
if (!passesLeptonStep)continue;
if (!gotPV)
{
iEvent.getByLabel(vertexZ_, vertexZ);
npv = vertexZ->size();
}
ntchpt_tags = 0;
ncsvl_tags = 0;
ncsvt_tags = 0;
ncsvm_tags = 0;
ntight_tags = 0;
jsfshpt.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvt.clear();// bjs.clear();cjs.clear();ljs.clear();
jsfscsvm.clear();// bjs.clear();cjs.clear();ljs.clear();
bool hasTurnOnWeight = false;
double turnOnWeightValue = 1;
turnOnReWeightTree = 1;
turnOnWeightTreeJetTrig1Up = 1;
turnOnWeightTreeJetTrig1Down = 1;
turnOnWeightTreeJetTrig2Up = 1;
turnOnWeightTreeJetTrig2Down = 1;
turnOnWeightTreeJetTrig3Up = 1;
turnOnWeightTreeJetTrig3Down = 1;
turnOnWeightTreeBTagTrig1Up = 1;
turnOnWeightTreeBTagTrig1Down = 1;
turnOnWeightTreeBTagTrig2Up = 1;
turnOnWeightTreeBTagTrig2Down = 1;
turnOnWeightTreeBTagTrig3Up = 1;
turnOnWeightTreeBTagTrig3Down = 1;
bWeightTree = 1;
bWeightTreeBTagUp = 1;
bWeightTreeMisTagUp = 1;
bWeightTreeBTagDown = 1;
bWeightTreeMisTagDown = 1;
if (!gotMets)
{
iEvent.getByLabel(METPhi_, METPhi);
iEvent.getByLabel(METPt_, METPt);
metPx = METPt->at(0) * cos(METPhi->at(0));
metPy = METPt->at(0) * sin(METPhi->at(0));
metPxTmp = metPx;
metPyTmp = metPy;
metPhi = METPhi->at(0);
gotMets = true;
}
metPx = metPxTmp;
metPy = metPyTmp;
if (syst_name == "UnclusteredMETUp")
{
iEvent.getByLabel(UnclMETPx_, UnclMETPx);
iEvent.getByLabel(UnclMETPy_, UnclMETPy);
metPx += (*UnclMETPx) * 0.1;
metPy += (*UnclMETPy) * 0.1;
}
if (syst_name == "UnclusteredMETDown")
{
iEvent.getByLabel(UnclMETPx_, UnclMETPx);
iEvent.getByLabel(UnclMETPy_, UnclMETPy);
metPx -= (*UnclMETPx) * 0.1;
metPy -= (*UnclMETPy) * 0.1;
}
if (!gotJets)
{
iEvent.getByLabel(jetsEta_, jetsEta);
iEvent.getByLabel(jetsPhi_, jetsPhi);
iEvent.getByLabel(jetsEnergy_, jetsEnergy);
iEvent.getByLabel(jetsBTagAlgo_, jetsBTagAlgo);
iEvent.getByLabel(jetsAntiBTagAlgo_, jetsAntiBTagAlgo);
iEvent.getByLabel(jetsPileUpID_, jetsPileUpID);
iEvent.getByLabel(jetsPileUpWP_, jetsPileUpWP);
iEvent.getByLabel(jetsBeta_, jetsBeta);
iEvent.getByLabel(jetsDZ_, jetsDZ);
iEvent.getByLabel(jetsRMS_, jetsRMS);
iEvent.getByLabel(jetsFlavour_, jetsFlavour);
iEvent.getByLabel(jetsCorrTotal_, jetsCorrTotal);
if (doResol_)iEvent.getByLabel(genJetsPt_, genJetsPt);
gotJets = true;
}
if (syst == "noSyst"
|| syst == "JESUp" || syst == "JESDown"
|| syst == "JERUp" || syst == "JERDown"
|| syst == "BTagUp" || syst == "BTagDown"
|| syst == "MisTagUp" || syst == "MisTagDown"
)
{
for (size_t i = 0; i < jetsPt->size(); ++i)
{
eta = jetsEta->at(i);
if (fabs(eta ) > 4.7)continue;
ptCorr = jetsPt->at(i);
flavour = jetsFlavour->at(i);
double energyCorr = jetsEnergy->at(i);
float genpt = -1.;
if (doResol_)genpt = genJetsPt->at(i);
float rndm = 0.1;
//If systematics JES up/down we need to change the pt of the jet
//consider if it passes the threshold or not
double smear = 1.;//TMath::QuietNaN();
if (doResol_ && genpt > 0.0)
{
resolScale = resolSF(fabs(eta), syst_name);
smear = std::max((double)(0.0), (double)(ptCorr + (ptCorr - genpt) * resolScale) / ptCorr);
}
energyCorr = energyCorr * smear;
ptCorr = ptCorr * smear;
// metPx -= (jetsPt->at(i) * cos(jetsPhi->at(i))) * (smear-1);
//metPy -= (jetsPt->at(i) * sin(jetsPhi->at(i))) * (smear-1);
if (syst_name == "JESUp")
{
unc = jetUncertainty( eta, ptCorr, flavour);
// cout << syst << " "<< unc << endl;
ptCorr = ptCorr * (1 + unc);
energyCorr = energyCorr * (1 + unc);
}
if (syst_name == "JESDown")
{
unc = jetUncertainty( eta, ptCorr, flavour);
ptCorr = ptCorr * (1 - unc);
energyCorr = energyCorr * (1 - unc);
}
HT+= (math::PtEtaPhiELorentzVector(ptCorr, jetsEta->at(i), jetsPhi->at(i), energyCorr)).Et();
// cout << "jet i " << i << endl;
//Pt cut
bool passesPtCut = ptCorr > ptCut;
if (passesPtCut)
{
++nJets;
if ( fabs(eta) < 2.5)++nJetsCentral;
else ++nJetsForward;
if ( jetsPileUpWP->at(i) > 2.5)
{
++nJetsNoPU;
if ( fabs(eta) < 2.5)++nJetsCentralNoPU;
else ++nJetsForwardNoPU;
}
jets[nJets - 1] = math::PtEtaPhiELorentzVector(ptCorr, jetsEta->at(i), jetsPhi->at(i), energyCorr);
flavours[nJets - 1] = flavour;
if (syst == "noSyst")
{
++nJetsNoSyst;
jetsNoSyst[nJets - 1] = jets[nJets - 1];
// cout <<" jet no syst "<< nJets-1<<" pt " <<jetsNoSyst[nJets-1].pt()<<endl;
}
}
//b tag thresholds
double valueTCHPT = jetsBTagAlgo->at(i);
double valueCSV = jetsAntiBTagAlgo->at(i);
bool passesTCHPT = jetsBTagAlgo->at(i) > 3.41; //TCHPT Working point
bool passesCSVT = jetsAntiBTagAlgo->at(i) > 0.898; //TCHPT Working point
bool passesCSVM = jetsAntiBTagAlgo->at(i)>0.679;//CSVM Working point
// bool passesCSVM = jetsAntiBTagAlgo->at(i)>0.244;//CSVL Working point
double valueChosenAlgo = valueCSV;
if (algo_ == "TCHPT")valueChosenAlgo = valueTCHPT;
if (!passesPtCut) continue;
//max pt position:
int pos = nJets - 1;
//cout << " pos " << pos << " j pt " << ptCorr << endl;
if (ptCorr > maxPtTree)
{
maxPtTreePosition = nJets - 1;
maxPtTree = ptCorr;
firstJetFlavourTree = flavour;
}
//min pt position:
if (ptCorr < minPtTree)
{
minPtTreePosition = nJets - 1;
minPtTree = ptCorr;
}
//Passes first algorithm (b tag requirement in the case of t-channel standard selection)
double etaMin = min(fabs(eta), (float)2.3999);
double ptMin = min(ptCorr, (float)239.9); //min(jets.back().pt(),998.0);
measurePoint.insert(BinningVariables::JetAbsEta, etaMin);
measurePoint.insert(BinningVariables::JetEt, ptMin);
//Apply different SFs if it is b,c or light jet
if (abs(flavour) == 4)
{
++nc;
if (is_btag_relevant )
{
double hptSF = 1;
double hptSFErr = 0;
double csvtSF = 1;
double csvtSFErr = 0;
double csvmSF = 1;
double csvmSFErr = 0;
double hpteff = EFFMap("TCHPT_C");
double csvteff = EFFMap("CSVT_C", channel);
double csvmeff = EFFMap("CSVL_C", channel);
if (abs(eta) > 2.6)
{
hpteff = 0;
csvteff = 0;
csvmeff = 0;
}
if ( takeBTagSFFromDB_)
{
hptSF = (perfBHP->getResult(PerformanceResult::BTAGBEFFCORR, measurePoint));
hptSFErr = fabs(perfBHP->getResult(PerformanceResult::BTAGBERRCORR, measurePoint));
}
else
{
hptSF = BTagSFNew(ptCorr, "TCHPT");
csvtSF = BTagSFNew(ptCorr, "CSVT");
csvmSF = BTagSFNew(ptCorr, "CSVL");
hptSFErr = BTagSFErrNew(ptCorr, "TCHPT") ;
csvtSFErr = BTagSFErrNew(ptCorr, "CSVT") ;
csvmSFErr = BTagSFErrNew(ptCorr, "CSVL") ;
}
jsfshpt.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfshpt_mis_tag_up.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfshpt_mis_tag_down.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfscsvt.push_back(BTagWeight::JetInfo(csvteff, csvtSF));
jsfscsvt_mis_tag_up.push_back(BTagWeight::JetInfo(csvteff, csvtSF));
jsfscsvt_mis_tag_down.push_back(BTagWeight::JetInfo(csvteff, csvtSF));
jsfscsvm.push_back(BTagWeight::JetInfo(csvmeff, csvmSF));
jsfscsvm_mis_tag_up.push_back(BTagWeight::JetInfo(csvmeff, csvmSF));
jsfscsvm_mis_tag_down.push_back(BTagWeight::JetInfo(csvmeff, csvmSF));
if (syst == "noSyst")
{
jsfshpt_b_tag_up.push_back(BTagWeight::JetInfo(hpteff, hptSF + 2 * hptSFErr));
jsfshpt_b_tag_down.push_back(BTagWeight::JetInfo(hpteff, hptSF - 2 * hptSFErr));
jsfscsvt_b_tag_up.push_back(BTagWeight::JetInfo(csvteff, csvtSF + 2 * csvtSFErr));
jsfscsvt_b_tag_down.push_back(BTagWeight::JetInfo(csvteff, csvtSF - 2 * csvtSFErr));
jsfscsvm_b_tag_up.push_back(BTagWeight::JetInfo(csvmeff, csvmSF + 2 * csvmSFErr));
jsfscsvm_b_tag_down.push_back(BTagWeight::JetInfo(csvmeff, csvmSF - 2 * csvmSFErr));
}
}
}
else if (abs(flavour) == 5)
{
++nb;
if (is_btag_relevant )
{
double hptSF = 1;
double hptSFErr = 0;
double csvtSF = 1;
double csvtSFErr = 0;
double csvmSF = 1;
double csvmSFErr = 0;
double hpteff = EFFMap("TCHPT_B");
double csvteff = EFFMap("CSVT_B", channel);
double csvmeff = EFFMap("CSVL_B", channel);
if (abs(eta) > 2.6)
{
hpteff = 0;
csvteff = 0;
csvmeff = 0;
}
if ( takeBTagSFFromDB_)
{
hptSF = (perfBHP->getResult(PerformanceResult::BTAGBEFFCORR, measurePoint));
hptSFErr = fabs(perfBHP->getResult(PerformanceResult::BTAGBERRCORR, measurePoint));
}
else
{
hptSF = BTagSFNew(ptCorr, "TCHPT");
csvtSF = BTagSFNew(ptCorr, "CSVT");
csvmSF = BTagSFNew(ptCorr, "CSVL");
hptSFErr = BTagSFErrNew(ptCorr, "TCHPT") ;
csvtSFErr = BTagSFErrNew(ptCorr, "CSVT") ;
csvmSFErr = BTagSFErrNew(ptCorr, "CSVL") ;
}
jsfshpt.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfshpt_mis_tag_up.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfshpt_mis_tag_down.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfscsvt.push_back(BTagWeight::JetInfo(csvteff, csvtSF));
jsfscsvt_mis_tag_up.push_back(BTagWeight::JetInfo(csvteff, csvtSF));
jsfscsvt_mis_tag_down.push_back(BTagWeight::JetInfo(csvteff, csvtSF));
jsfscsvm.push_back(BTagWeight::JetInfo(csvmeff, csvmSF));
jsfscsvm_mis_tag_up.push_back(BTagWeight::JetInfo(csvmeff, csvmSF));
jsfscsvm_mis_tag_down.push_back(BTagWeight::JetInfo(csvmeff, csvmSF));
if (syst == "noSyst")
{
jsfshpt_b_tag_up.push_back(BTagWeight::JetInfo(hpteff, hptSF + hptSFErr));
jsfshpt_b_tag_down.push_back(BTagWeight::JetInfo(hpteff, hptSF - hptSFErr));
jsfscsvt_b_tag_up.push_back(BTagWeight::JetInfo(csvteff, csvtSF + csvtSFErr));
jsfscsvt_b_tag_down.push_back(BTagWeight::JetInfo(csvteff, csvtSF - csvtSFErr));
jsfscsvm_b_tag_up.push_back(BTagWeight::JetInfo(csvmeff, csvmSF + csvmSFErr));
jsfscsvm_b_tag_down.push_back(BTagWeight::JetInfo(csvmeff, csvmSF - csvmSFErr));
}
}
}
else
{
if (is_btag_relevant )
{
double hptSF = 1;
double hptSFErrUp = 0;
double hptSFErrDown = 0;
double csvtSF = 1;
double csvtSFErrUp = 0;
double csvtSFErrDown = 0;
double csvmSF = 1;
double csvmSFErrUp = 0;
double csvmSFErrDown = 0;
double hpteff = EFFMap("TCHPT_L");
double csvteff = EFFMap("CSVT_L", channel);
double csvmeff = EFFMap("CSVL_L", channel);
if (abs(eta) > 2.6)
{
hpteff = 0;
csvteff = 0;
csvmeff = 0;
}
if ( takeBTagSFFromDB_)
{
hpteff = (perfMHP->getResult(PerformanceResult::BTAGLEFF, measurePoint));
hptSF = (perfMHP->getResult(PerformanceResult::BTAGLEFFCORR, measurePoint));
}
else
{
hptSF = MisTagSFNew(ptCorr, eta, "TCHPT");
hptSFErrUp = MisTagSFErrNewUp(ptCorr, eta, "TCHPT");
hptSFErrDown = MisTagSFErrNewDown(ptCorr, eta, "TCHPT");
csvmSF = MisTagSFNew(ptCorr, eta, "CSVL");
csvmSFErrUp = MisTagSFErrNewUp(ptCorr, eta, "CSVL");
csvmSFErrDown = MisTagSFErrNewDown(ptCorr, eta, "CSVL");
csvtSF = MisTagSFNew(ptCorr, eta, "CSVT");
csvtSFErrUp = MisTagSFErrNewUp(ptCorr, eta, "CSVT");
csvtSFErrDown = MisTagSFErrNewDown(ptCorr, eta, "CSVT");
}
jsfshpt.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfshpt_b_tag_up.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfshpt_b_tag_down.push_back(BTagWeight::JetInfo(hpteff, hptSF));
jsfscsvt.push_back(BTagWeight::JetInfo(csvteff, hptSF));
jsfscsvt_b_tag_up.push_back(BTagWeight::JetInfo(csvteff, hptSF));
jsfscsvt_b_tag_down.push_back(BTagWeight::JetInfo(csvteff, hptSF));
jsfscsvm.push_back(BTagWeight::JetInfo(csvmeff, hptSF));
jsfscsvm_b_tag_up.push_back(BTagWeight::JetInfo(csvmeff, hptSF));
jsfscsvm_b_tag_down.push_back(BTagWeight::JetInfo(csvmeff, hptSF));
if (syst == "noSyst")
{
jsfshpt_mis_tag_up.push_back(BTagWeight::JetInfo(hpteff, hptSFErrUp));
jsfshpt_mis_tag_down.push_back(BTagWeight::JetInfo(hpteff, hptSFErrDown));
jsfscsvt_mis_tag_up.push_back(BTagWeight::JetInfo(csvteff, csvtSFErrUp));
jsfscsvt_mis_tag_down.push_back(BTagWeight::JetInfo(csvteff, csvtSFErrDown));
jsfscsvm_mis_tag_up.push_back(BTagWeight::JetInfo(csvmeff, csvmSFErrUp));
jsfscsvm_mis_tag_down.push_back(BTagWeight::JetInfo(csvmeff, csvmSFErrDown));
}
}
++nudsg;
}
if (is_btag_relevant) measurePoint.reset();
if (passesCSVT)
{
++ncsvt_tags;
}
if (passesCSVM)
{
++ncsvm_tags;
}
if (passesTCHPT)
{
//Add to b-jet collection
++ntchpt_tags;
}
// cout << " jet i P2 "<< i << endl;
bool passesAlgo = passesCSVT;
if(passesCSVM) ++ncsvl_tags;
if (algo_ == "TCHPT" ) passesAlgo = passesTCHPT;
if (passesAlgo)
{
if (syst == "noSyst" ) ++nBJets;
bjets[nBJets - 1] = jets[nJets - 1];
}
//Condition to find the highest/lowest b-tag
//according to algo 1 (tchp)
//cout << " i "<< i <<" jets size "<< nJets << " btag "<< valueAlgo1<<endl;
if (valueChosenAlgo > highBTagTree)
{
highBTagTree = valueChosenAlgo;
highBTagTreePosition = nJets - 1;
bJetFlavourTree = jetsFlavour->at(i);
bJetPUID = jetsPileUpID->at(i);
bJetPUWP = jetsPileUpWP->at(i);
bJetBeta = jetsBeta->at(i);
bJetDZ = jetsDZ->at(i);
bJetRMS = jetsRMS->at(i);
}
if (valueChosenAlgo < lowBTagTree)
{
lowBTagTree = valueChosenAlgo;
lowBTagTreePosition = nJets - 1;
fJetFlavourTree = jetsFlavour->at(i);
fJetPUID = jetsPileUpID->at(i);
fJetPUWP = jetsPileUpWP->at(i);
fJetBeta = jetsBeta->at(i);
fJetDZ = jetsDZ->at(i);
fJetRMS = jetsRMS->at(i);
}
if (nJets >= 10 )break;
}
}
if (syst == "noSyst")
{
highBTagTreePositionNoSyst = highBTagTreePosition;
lowBTagTreePositionNoSyst = lowBTagTreePosition;
maxPtTreePositionNoSyst = maxPtTreePosition;
minPtTreePositionNoSyst = minPtTreePosition;
nbNoSyst = nb;
ncNoSyst = nc;
nudsgNoSyst = nudsg;
jsfshptNoSyst = jsfshpt;
}
if (!(syst == "noSyst"
|| syst == "JESUp" || syst == "JESDown"
|| syst == "JERUp" || syst == "JERDown"
|| syst == "BTagUp" || syst == "BTagDown"
|| syst == "MisTagUp" || syst == "MisTagDown" ))
{
nJets = nJetsNoSyst;
ncsvt_tags = nBJets;
if (algo_ == "TCHPT" ) ntchpt_tags = nBJets;
ntchel_tags = nLooseBJets;
nb = nbNoSyst;
nc = ncNoSyst;
nudsg = nudsgNoSyst;
for (size_t a = 0; a < nJetsNoSyst; ++a)
{
jets[a] = jetsNoSyst[a];
// cout <<" jet no syst "<< a <<" pt " <<jets[a].pt()<<endl;
}
highBTagTreePosition = highBTagTreePositionNoSyst;
lowBTagTreePosition = lowBTagTreePositionNoSyst;
maxPtTreePosition = maxPtTreePositionNoSyst;
minPtTreePosition = minPtTreePositionNoSyst;
jsfshpt = jsfshptNoSyst;
}
/*
//cout <<" syst "<< syst<< " njets "<< nJets << " nJetsNoSyst " << nJetsNoSyst << " nBJets "<< ntchpt_tags<<
" nBJetsNoSyst "<< nBJets<< " nb "<< nb << " nbNoSyst "<<nbNoSyst<< " lowBPos " <<lowBTagTreePosition << " lowBNoSyst " <<
lowBTagTreePositionNoSyst<<endl;
*/
if (!isQCD && leptonsFlavour_ == "mon")
{
for (size_t l = 0; l < nLeptons; ++l)
{
for (size_t j = 0; j < nJets; ++j)
{
if ( deltaR( leptons[l], jets[j]) < 0.3 )
{
;
--passingLepton;
passesLeptonStep = false;
}
}
}
}
if (passesLeptonStep == false)continue;
eventFlavourTree = eventFlavour(channel, nb, nc, nudsg);
//if( !flavourFilter(channel,nb,nc,nudsg) ) continue;
if ( syst_name == "JESUp" || syst_name == "JESDown" || syst_name == "JERDown" || syst_name == "JERUp" || syst_name == "noSyst"){
if(!gotAllJets){
iEvent.getByLabel(allJetsPt_, allJetsPt);
iEvent.getByLabel(allJetsPhi_, allJetsPhi);
iEvent.getByLabel(allJetsEta_, allJetsEta);
iEvent.getByLabel(allJetsFlavour_, allJetsFlavour);
if (doResol_)iEvent.getByLabel(genAllJetsPt_, genAllJetsPt);
gotAllJets = true ;
}
for (size_t i = 0; i < allJetsPt->size(); ++i) {
double ptCorr = allJetsPt->at(i);
double eta = allJetsEta->at(i);
double flavour = allJetsFlavour->at(i);
double jphi = allJetsPhi->at(i);
if(ptCorr < 10) continue;
/* if (syst_name == "JERUp" || syst_name == "JERDown"){
if(ptCorr > 40) continue;
metPx -= (ptCorr * cos(jphi)) * unc;
metPy -= (ptCorr * sin(jphi)) * unc;
}*/
double energyCorr =1.;
double smear = 1.;//TMath::QuietNaN();
double resolScale =0.;
double unc=0.;
float genpt = -1.;
if (doResol_)genpt = genAllJetsPt->at(i);
float rndm = 0.1;
cout << " genpt = "<< genpt<<endl;
if (doResol_ && genpt > 0.0)
{
resolScale = resolSF(fabs(eta), syst_name);
smear = std::max((double)(0.0), (double)(ptCorr + (ptCorr - genpt) * resolScale) / ptCorr);
}
metPx -= (ptCorr * cos(jphi)) * (smear-1);
metPy -= (ptCorr * sin(jphi)) * (smear-1);
cout << " correction x" << (ptCorr * cos(jphi)) * (smear-1) <<" met " << metPx <<endl;
energyCorr = energyCorr * smear;
ptCorr = ptCorr * smear;
if (syst_name == "JESUp")
{
unc = jetUncertainty( eta, ptCorr, flavour);
metPx -= (ptCorr * cos(jphi)) * unc;
metPy -= (ptCorr * sin(jphi)) * unc;
}
if (syst_name == "JESDown")
{
unc = jetUncertainty( eta, ptCorr, flavour);
metPx -= -(ptCorr * cos(jphi)) * unc;
metPy -= -(ptCorr * sin(jphi)) * unc;
}
}
}
/////////
///End of the standard lepton-jet loop
/////////
if (doPU_)
{
if (!gotPU )
{
// //cout << " before npv "<<endl;
iEvent.getByLabel(n0_, n0);
nVertices = *n0;
gotPU = true;
}
}
else(nVertices = -1);
if (doPU_)
{
if (syst == "noSyst")
{
PUWeightNoSyst = pileUpSF(syst); PUWeight = PUWeightNoSyst;
PUWeightTreePUUp = pileUpSF("PUUp");
PUWeightTreePUDown = pileUpSF("PUDown");
// cout<< "n0 " << nVertices << " weight = "<< PUWeightNoSyst<< " cross-check " <<endl;
}
else PUWeight = PUWeightNoSyst;
}
else PUWeight = 1;
PUWeightTree = PUWeight;
weightTree = Weight;
//Jet trees:
if (isQCD)
{
leptonPFour = qcdLeptons[0];
chargeTree = qcdLeptonsCharge->at(0) ;
}
else
{
leptonPFour = leptons[0];
chargeTree = leptonsCharge->at(0) ;
}
metPt = sqrt(metPx * metPx + metPy * metPy);
MTWValue = sqrt((leptonPFour.pt() + metPt) * (leptonPFour.pt() + metPt) - (leptonPFour.px() + metPx) * (leptonPFour.px() + metPx) - (leptonPFour.py() + metPy) * (leptonPFour.py() + metPy));
mtwMassTree = MTWValue;
bool passesMet = false;
runTree = iEvent.eventAuxiliary().run();
lumiTree = iEvent.eventAuxiliary().luminosityBlock();
eventTree = iEvent.eventAuxiliary().event();
for (size_t J_ = 0; J_ < nJets; ++J_ )
{
double ptCorr = jets[J_].pt();
if (ptCorr > secondPt && ptCorr < maxPtTree)
{
secondPt = ptCorr;
secondPtPosition = J_ ;
secondJetFlavourTree = flavours[J_];
}
}
for (size_t J_ = 0; J_ < nJets; ++J_ )
{
double ptCorr = jets[J_].pt();
if (ptCorr > thirdPt && ptCorr < secondPt)
{
thirdPt = ptCorr;
thirdPtPosition = J_;
thirdJetFlavourTree = flavours[J_];
}
}
//if (thirdPt > secondPt ) cout << " sanity check: Pt3 > Pt2 at event" << eventTree << " njets "<< nJets <<endl;
//if (secondPt > maxPtTree ) cout << " sanity check: Pt2 > Pt1 at event" << eventTree <<" njets "<< nJets <<endl;
//if (thirdPt > maxPtTree ) cout << " sanity check: Pt3 > Pt1 at event" << eventTree << " njets "<< nJets <<endl;
if (nJets > 0)
{
firstJetPt = jets[maxPtTreePosition].pt();
firstJetE = jets[maxPtTreePosition].energy();
firstJetEta = jets[maxPtTreePosition].eta();
firstJetPhi = jets[maxPtTreePosition].phi();
if (nJets > 1)
{
secondJetPt = jets[secondPtPosition].pt();
secondJetE = jets[secondPtPosition].energy();
secondJetEta = jets[secondPtPosition].eta();
secondJetPhi = jets[secondPtPosition].phi();
}
if (nJets > 2)
{
thirdJetPt = jets[thirdPtPosition].pt();
thirdJetE = jets[thirdPtPosition].energy();
thirdJetEta = jets[thirdPtPosition].eta();
thirdJetPhi = jets[thirdPtPosition].phi();
}
}
else
{
firstJetFlavourTree = 0;
secondJetFlavourTree = 0;
thirdJetFlavourTree = 0;
firstJetPt = 0;
firstJetE = 0;
firstJetEta = -99;
firstJetPhi = -99;
secondJetPt = 0;
secondJetE = 0;
secondJetEta = -99;
secondJetPhi = -99;
thirdJetPt = 0;
thirdJetE = 0;
thirdJetEta = -99;
thirdJetPhi = -99;
}
if(doJetTrees_)isQCDTree= isQCD;
if (doJetTrees_ && !isQCD)
{
if (syst == "noSyst")
{
jetprobs.clear();
for (size_t i = 0; i < jetsEta->size(); ++i)
{
double eta = jetsEta->at(i);
double btag = jetsBTagAlgo->at(i);
double pt = jetsPt->at(i);
if (fabs(eta) > 2.6) jetprobs.push_back(0.);
jetprobs.push_back(jetprob(pt, btag, eta, syst));
}
if (leptonsFlavour_ == "muon" )lepEff = muonHLTEff(leptons[0].eta(),"Mu2012A");
if (leptonsFlavour_ == "muon" )lepEffB = muonHLTEff(leptons[0].eta(),"Mu2012B");
if (leptonsFlavour_ == "muon" ) muonHLTSF(leptons[0].eta(),leptons[0].pt());
if (leptonsFlavour_ == "electron" ) electronHLTSF(leptons[0].eta(),leptons[0].pt());
lepPt = leptons[0].pt();
if(doTurnOn_)turnOnWeightValue = turnOnProbs("noSyst", 1);
if(doBTagSF_){w1TCHPT = b_tchpt_1_tag.weight(jsfshpt, ntchpt_tags);
w2TCHPT = b_tchpt_2_tags.weight(jsfshpt, ntchpt_tags);
w1CSVT = b_csvt_1_tag.weight(jsfscsvt, ncsvt_tags);
w2CSVT = b_csvt_2_tags.weight(jsfscsvt, ncsvt_tags);
w1CSVM = b_csvm_1_tag.weight(jsfscsvt, ncsvm_tags);
w2CSVM = b_csvm_2_tags.weight(jsfscsvt, ncsvm_tags);
}
nJ = nJets;
nJNoPU = nJetsNoPU;
nJCentralNoPU = nJetsCentralNoPU;
nJCentral = nJetsCentral;
nJForwardNoPU = nJetsForwardNoPU;
nJForward = nJetsForward;
if(addPDFToNJets){
iEvent.getByLabel(x1_, x1h);
iEvent.getByLabel(x2_, x2h);
iEvent.getByLabel(scalePDF_, scalePDFh);
iEvent.getByLabel(id1_, id1h);
iEvent.getByLabel(id2_, id2h);
x1 = *x1h;
x2 = *x2h;
scalePDF = *scalePDFh;
id1 = *id1h;
id2 = *id2h;
LHAPDF::usePDFMember(1, 0);
double xpdf1 = LHAPDF::xfx(1, x1, scalePDF, id1);
double xpdf2 = LHAPDF::xfx(1, x2, scalePDF, id2);
double w0 = xpdf1 * xpdf2;
for (int p = 1; p <= 52; ++p)
{
LHAPDF::usePDFMember(1, p);
double xpdf1_new = LHAPDF::xfx(1, x1, scalePDF, id1);
double xpdf2_new = LHAPDF::xfx(1, x2, scalePDF, id2);
double pweight = xpdf1_new * xpdf2_new / w0;
pdf_weights[p - 1] = pweight;
}
LHAPDF::usePDFMember(2, 0);
double xpdf1_new = LHAPDF::xfx(2, x1, scalePDF, id1);
double xpdf2_new = LHAPDF::xfx(2, x2, scalePDF, id2);
pdf_weights_mstw= xpdf1_new * xpdf2_new / w0;
LHAPDF::usePDFMember(3, 0);
xpdf1_new = LHAPDF::xfx(3, x1, scalePDF, id1);
xpdf2_new = LHAPDF::xfx(3, x2, scalePDF, id2);
pdf_weights_nnpdf21 = xpdf1_new * xpdf2_new / w0;
pdf_weights_gjr_fv = xpdf1_new * xpdf2_new / w0;
pdf_weights_gjr_ff = xpdf1_new * xpdf2_new / w0;
pdf_weights_gjr_fdis = xpdf1_new * xpdf2_new / w0;
gotPDFs = true;
}
treesNJets[syst]->Fill();
}
}
if (doJetTrees_ && isQCD && doQCD_)
{
lepPt = qcdLeptons[0].pt();
lepEta = qcdLeptons[0].eta();
lepPhi = qcdLeptons[0].phi();
treesNJets[syst]->Fill();
}
ntight_tags = ncsvt_tags;
if (algo_ == "TCHPT")ntight_tags = ntchpt_tags;
if ( nJets < 2 )continue;
if (nJets > 3)continue;
//LEGENDA
// 0T = 0;
// 1T = 1;
// 2T = 2;
// 0T_QCD=3;
// 1T_QCD=4;
// 2T_QCD=5;
if (nJets == 2 || nJets == 3)
{
int B;
if (ntight_tags == 0) B = 0 ;
else if (ntight_tags == 1)B = 1;
else if (ntight_tags == 2)B = 2;
else continue;
if(lepRhoCorrectedRelIso>0.1){
cout<< "rho corr rel iso is: " <<lepRhoCorrectedRelIso<< " leptons size "<<nLeptons<< " B is " << B << " nJets is " << nJets << " is qcd? "<< isQCD << " passes lepton? "<< passesLeptonStep <<endl;
}
if (isQCD)
{
B += 3;
}
if ( syst == "noSyst" && nJets == 2 && B < 3)
{
++passingJets;
}
if ( (B == 0 || B == 3 ) && (ntchpt_tags != 0 || lowBTagTreePosition < 0 || lowBTagTreePosition == highBTagTreePosition) ) continue; //Sample A condition, ok for now
if(doLooseBJetVeto_)if(nJets==2 && (B == 1 || B==4))if( ncsvl_tags != 1 )continue;
if (syst == "noSyst")
{
bWeightNoSyst = bTagSF(B); bWeightTree = bWeightNoSyst;
bWeightTreeBTagUp = bTagSF(B, "BTagUp");
bWeightTreeBTagDown = bTagSF(B, "BTagDown");
bWeightTreeMisTagUp = bTagSF(B, "MisTagUp");
bWeightTreeMisTagDown = bTagSF(B, "MisTagDown");
}
else if (syst == "JESUp" || syst == "JESDown" ||
syst == "JERUp" || syst == "JERDown" ||
syst == "BTagUp" || syst == "BTagDown" ||
syst == "MisTagUp" || syst == "MisTagDown" ) bWeightTree = bTagSF(B);
else bWeightTree = bWeightNoSyst;
if ( //leptonsFlavour_ == "electron" &&
doTurnOn_)
{
if (syst == "noSyst" && (B == 1 || B == 4))
{
jetprobs.clear();
jetprobs_j1up.clear();
jetprobs_j2up.clear();
jetprobs_j3up.clear();
jetprobs_b1up.clear();
jetprobs_b2up.clear();
jetprobs_b3up.clear();
jetprobs_j1down.clear();
jetprobs_j2down.clear();
jetprobs_j3down.clear();
jetprobs_b1down.clear();
jetprobs_b2down.clear();
jetprobs_b3down.clear();
for (size_t i = 0; i < jetsEta->size(); ++i)
{
double eta = jetsEta->at(i);
double btag = jetsBTagAlgo->at(i);
double pt = jetsPt->at(i);
pushJetProbs(pt, btag, eta);
}
//cout << "right before turn on "<< endl;
turnOnWeightValue = turnOnProbs("noSyst", 1);
turnOnWeightTreeJetTrig1Up = turnOnProbs("JetTrig1Up", 1);
turnOnWeightTreeJetTrig1Down = turnOnProbs("JetTrig1Down", 1);
turnOnWeightTreeJetTrig2Up = turnOnProbs("JetTrig2Up", 1);
turnOnWeightTreeJetTrig2Down = turnOnProbs("JetTrig2Down", 1);
turnOnWeightTreeJetTrig3Up = turnOnProbs("JetTrig3Up", 1);
turnOnWeightTreeJetTrig3Down = turnOnProbs("JetTrig3Down", 1);
turnOnWeightTreeBTagTrig1Up = turnOnProbs("BTagTrig1Up", 1);
turnOnWeightTreeBTagTrig1Down = turnOnProbs("BTagTrig1Down", 1);
turnOnWeightTreeBTagTrig2Up = turnOnProbs("BTagTrig2Up", 1);
turnOnWeightTreeBTagTrig2Down = turnOnProbs("BTagTrig2Down", 1);
turnOnWeightTreeBTagTrig3Up = turnOnProbs("BTagTrig3Up", 1);
turnOnWeightTreeBTagTrig3Down = turnOnProbs("BTagTrig3Down", 1);
// turnOnWeightValue = turnOnWeight(jetprobs,1);
if (syst == "noSyst") turnOnWeightValueNoSyst = turnOnWeightValue;
if (syst == "noSyst") turnOnReWeightTreeNoSyst = turnOnReWeight(turnOnWeightValue, jets[highBTagTreePosition].pt(), highBTagTree);
}
else
{
jetprobs.clear();
for (size_t i = 0; i < jetsEta->size(); ++i)
{
double eta = jetsEta->at(i);
double btag = jetsBTagAlgo->at(i);
double pt = jetsPt->at(i);
if (fabs(eta) > 2.6) jetprobs.push_back(0.);
jetprobs.push_back(jetprob(pt, btag, eta, syst));
}
turnOnWeightValue = turnOnWeight(jetprobs, 1);
turnOnWeightTreeJetTrig1Up = turnOnWeightValue;
turnOnWeightTreeJetTrig1Down = turnOnWeightValue;
turnOnWeightTreeJetTrig2Up = turnOnWeightValue;
turnOnWeightTreeJetTrig2Down = turnOnWeightValue;
turnOnWeightTreeJetTrig3Up = turnOnWeightValue;
turnOnWeightTreeJetTrig3Down = turnOnWeightValue;
turnOnWeightTreeBTagTrig1Up = turnOnWeightValue;
turnOnWeightTreeBTagTrig1Down = turnOnWeightValue;
turnOnWeightTreeBTagTrig2Up = turnOnWeightValue;
turnOnWeightTreeBTagTrig2Down = turnOnWeightValue;
turnOnWeightTreeBTagTrig3Up = turnOnWeightValue;
turnOnWeightTreeBTagTrig3Down = turnOnWeightValue;
}
// //cout << "jetprobs @syst: " << syst << " test 3" <<endl;
////cout << " njets "<< nJets << " high b-tag " <<highBTagTree<< " high b-tag tree position" << highBTagTreePosition<<endl;
turnOnReWeightTree = turnOnReWeightTreeNoSyst;
}
if (leptonsFlavour_ == "none" && doTurnOn_)
{
jetprobs.clear();
for (size_t i = 0; i < jetsEta->size(); ++i)
{
double eta = jetsEta->at(i);
double btag = jetsBTagAlgo->at(i);
double pt = jetsPt->at(i);
if (fabs(eta) > 2.6) jetprobs.push_back(0.);
jetprobs.push_back(jetprobbtag(btag));
}
turnOnWeightValue = turnOnWeight(jetprobs, 1);
}
if (syst == "noSyst" && doPDF_ )
{
if (channel != "Data" && !gotPDFs)
{
iEvent.getByLabel(x1_, x1h);
iEvent.getByLabel(x2_, x2h);
iEvent.getByLabel(scalePDF_, scalePDFh);
iEvent.getByLabel(id1_, id1h);
iEvent.getByLabel(id2_, id2h);
x1 = *x1h;
x2 = *x2h;
scalePDF = *scalePDFh;
id1 = *id1h;
id2 = *id2h;
//Q2 = x1 * x2 * 7000*7000;
LHAPDF::usePDFMember(1, 0);
double xpdf1 = LHAPDF::xfx(1, x1, scalePDF, id1);
double xpdf2 = LHAPDF::xfx(1, x2, scalePDF, id2);
double w0 = xpdf1 * xpdf2;
//cout << "scale " << scalePDF<< " x1 "<< x1 <<" x2 "<< x2 <<endl;
for (int p = 1; p <= 52; ++p)
{
LHAPDF::usePDFMember(1, p);
double xpdf1_new = LHAPDF::xfx(1, x1, scalePDF, id1);
double xpdf2_new = LHAPDF::xfx(1, x2, scalePDF, id2);
double pweight = xpdf1_new * xpdf2_new / w0;
pdf_weights[p - 1] = pweight;
}
LHAPDF::usePDFMember(2, 0);
double xpdf1_new = LHAPDF::xfx(2, x1, scalePDF, id1);
double xpdf2_new = LHAPDF::xfx(2, x2, scalePDF, id2);
pdf_weights_mstw= xpdf1_new * xpdf2_new / w0;
LHAPDF::usePDFMember(3, 0);
xpdf1_new = LHAPDF::xfx(3, x1, scalePDF, id1);
xpdf2_new = LHAPDF::xfx(3, x2, scalePDF, id2);
pdf_weights_nnpdf21 = xpdf1_new * xpdf2_new / w0;
pdf_weights_gjr_fv = xpdf1_new * xpdf2_new / w0;
pdf_weights_gjr_ff = xpdf1_new * xpdf2_new / w0; // cout <<" gjr dis " << endl;
pdf_weights_gjr_fdis = xpdf1_new * xpdf2_new / w0;
}
}
turnOnWeightTree = turnOnWeightValue;
if ( syst == "noSyst" && nJets == 2)
{
if (leptonsFlavour_ == "muon" && MTWValue > 40 && B < 3 )
{
++passingMET;
passesMet = true;
}
if (leptonsFlavour_ == "electron" && metPt > 35 && B < 3)
{
++passingMET;
passesMet = true;
}
if ( B == 1 && passesMet)
++passingBJets;
}
math::PtEtaPhiELorentzVector top = top4Momentum(leptonPFour, jets[highBTagTreePosition], metPx, metPy);
float fCosThetaLJ = cosThetaLJ(leptonPFour, jets[lowBTagTreePosition], top);
cosBLTree = cosTheta_eta_bl(leptonPFour, jets[lowBTagTreePosition], top);
etaTree = fabs(jets[lowBTagTreePosition].eta());
cosTree = fCosThetaLJ;
topMassTree = top.mass();
topMtwTree = topMtw(leptonPFour, jets[highBTagTreePosition], metPx, metPy);
lepPt = leptonPFour.pt();
lepEta = leptonPFour.eta();
lepPhi = leptonPFour.phi();
if (leptonsFlavour_ == "muon" )lepEff = muonHLTEff(lepEta,"Mu2012A");
if (leptonsFlavour_ == "muon" )lepEffB = muonHLTEff(lepEta,"Mu2012B");
if (leptonsFlavour_ == "muon" )muonHLTSF(leptons[0].eta(),leptons[0].pt());
if (leptonsFlavour_ == "electron" )electronHLTSF(leptons[0].eta(),leptons[0].pt());
if (leptonsFlavour_ == "electron" )lepEff = 1;
bJetPt = jets[highBTagTreePosition].pt();
bJetE = jets[highBTagTreePosition].energy();
bJetEta = jets[highBTagTreePosition].eta();
bJetPhi = jets[highBTagTreePosition].phi();
fJetPt = jets[lowBTagTreePosition].pt();
fJetE = jets[lowBTagTreePosition].energy();
fJetEta = jets[lowBTagTreePosition].eta();
fJetPhi = jets[lowBTagTreePosition].phi();
totalWeightTree = bWeightTree * turnOnWeightValue * PUWeight * Weight;
etaTree = fabs(jets[lowBTagTreePosition].eta());
etaTree2 = fabs(jets[highBTagTreePosition].eta());
cosTree = fCosThetaLJ;
topEta = top.eta();
topPhi = top.phi();
topPt = top.pt();
if(B==1 && nJets ==2 && syst == "noSyst" && doMCTruth_ && ! doFullMCTruth_){
iEvent.getByLabel(MCTopsEta_, MCTopsEta); iEvent.getByLabel(MCTopsPt_, MCTopsPt); iEvent.getByLabel(MCTopsPhi_, MCTopsPhi); iEvent.getByLabel(MCTopsEnergy_, MCTopsEnergy); iEvent.getByLabel(MCTopsMotherId_, MCTopsMotherId);
iEvent.getByLabel(MCTopQuarksEta_, MCTopQuarksEta); iEvent.getByLabel(MCTopQuarksPt_, MCTopQuarksPt); iEvent.getByLabel(MCTopQuarksPhi_, MCTopQuarksPhi); iEvent.getByLabel(MCTopQuarksEnergy_, MCTopQuarksEnergy); iEvent.getByLabel(MCTopQuarksMotherId_, MCTopQuarksMotherId);
iEvent.getByLabel(MCTopQuarkBarsEta_, MCTopQuarkBarsEta); iEvent.getByLabel(MCTopQuarkBarsPt_, MCTopQuarkBarsPt); iEvent.getByLabel(MCTopQuarkBarsPhi_, MCTopQuarkBarsPhi); iEvent.getByLabel(MCTopQuarkBarsEnergy_, MCTopQuarkBarsEnergy); iEvent.getByLabel(MCTopQuarkBarsMotherId_, MCTopQuarkBarsMotherId);
iEvent.getByLabel(MCTopLeptonsEta_, MCTopLeptonsEta); iEvent.getByLabel(MCTopLeptonsPt_, MCTopLeptonsPt); iEvent.getByLabel(MCTopLeptonsPhi_, MCTopLeptonsPhi); iEvent.getByLabel(MCTopLeptonsEnergy_, MCTopLeptonsEnergy); iEvent.getByLabel(MCTopLeptonsMotherId_, MCTopLeptonsMotherId);
iEvent.getByLabel(MCTopNeutrinosEta_, MCTopNeutrinosEta); iEvent.getByLabel(MCTopNeutrinosPt_, MCTopNeutrinosPt); iEvent.getByLabel(MCTopNeutrinosPhi_, MCTopNeutrinosPhi); iEvent.getByLabel(MCTopNeutrinosEnergy_, MCTopNeutrinosEnergy); iEvent.getByLabel(MCTopNeutrinosMotherId_, MCTopNeutrinosMotherId);
iEvent.getByLabel(MCTopBQuarksEta_, MCTopBQuarksEta); iEvent.getByLabel(MCTopBQuarksPt_, MCTopBQuarksPt); iEvent.getByLabel(MCTopBQuarksPhi_, MCTopBQuarksPhi); iEvent.getByLabel(MCTopBQuarksEnergy_, MCTopBQuarksEnergy); iEvent.getByLabel(MCTopBQuarksMotherId_, MCTopBQuarksMotherId);
iEvent.getByLabel(MCTopWsEta_, MCTopWsEta); iEvent.getByLabel(MCTopWsPt_, MCTopWsPt); iEvent.getByLabel(MCTopWsPhi_, MCTopWsPhi); iEvent.getByLabel(MCTopWsEnergy_, MCTopWsEnergy); iEvent.getByLabel(MCTopWsDauOneId_, MCTopWsDauOneId);
iEvent.getByLabel(MCLeptonsEta_, MCLeptonsEta); iEvent.getByLabel(MCLeptonsPt_, MCLeptonsPt); iEvent.getByLabel(MCLeptonsPhi_, MCLeptonsPhi); iEvent.getByLabel(MCLeptonsEnergy_, MCLeptonsEnergy);
iEvent.getByLabel(MCNeutrinosEta_, MCNeutrinosEta); iEvent.getByLabel(MCNeutrinosPt_, MCNeutrinosPt); iEvent.getByLabel(MCNeutrinosPhi_, MCNeutrinosPhi); iEvent.getByLabel(MCNeutrinosEnergy_, MCNeutrinosEnergy);
iEvent.getByLabel(MCBQuarksEta_, MCBQuarksEta); iEvent.getByLabel(MCBQuarksPt_, MCBQuarksPt); iEvent.getByLabel(MCBQuarksPhi_, MCBQuarksPhi); iEvent.getByLabel(MCBQuarksEnergy_, MCBQuarksEnergy);
iEvent.getByLabel(MCQuarksEta_, MCQuarksEta); iEvent.getByLabel(MCQuarksPt_, MCQuarksPt); iEvent.getByLabel(MCQuarksPhi_, MCQuarksPhi); iEvent.getByLabel(MCQuarksEnergy_, MCQuarksEnergy);
iEvent.getByLabel(MCTopBQuarksPdgId_, MCTopBQuarksPdgId);iEvent.getByLabel(MCTopWsPdgId_, MCTopWsPdgId);
iEvent.getByLabel(MCTopQuarksPdgId_, MCTopQuarksPdgId);iEvent.getByLabel(MCTopsPdgId_, MCTopsPdgId);
iEvent.getByLabel(MCTopQuarkBarsPdgId_, MCTopQuarkBarsPdgId);
iEvent.getByLabel(MCTopLeptonsPdgId_, MCTopLeptonsPdgId);
iEvent.getByLabel(MCTopNeutrinosPdgId_, MCTopNeutrinosPdgId);
iEvent.getByLabel(MCBQuarksPdgId_, MCBQuarksPdgId); iEvent.getByLabel(MCQuarksPdgId_, MCQuarksPdgId);
iEvent.getByLabel(MCLeptonsPdgId_, MCLeptonsPdgId); iEvent.getByLabel(MCNeutrinosPdgId_, MCNeutrinosPdgId);
iEvent.getByLabel(MCBQuarksMotherId_, MCBQuarksMotherId); iEvent.getByLabel(MCQuarksMotherId_, MCQuarksMotherId);
iEvent.getByLabel(MCLeptonsMotherId_, MCLeptonsMotherId); iEvent.getByLabel(MCNeutrinosMotherId_, MCNeutrinosMotherId);
for (size_t p = 1; p <= 12; ++p){
// cout << "in loop 1" << endl;
if(!(MCQuarksEta->size() < p) ){
MCQuarksEtaVec[p-1]=MCQuarksEta->at(p-1);
// cout << " lepton eta "<< MCQuarksEtaVec[p-1]<<endl;
MCQuarksPhiVec[p-1]=MCQuarksPhi->at(p-1);
MCQuarksPtVec[p-1]=MCQuarksPt->at(p-1);
MCQuarksEnergyVec[p-1]=MCQuarksEnergy->at(p-1);
MCQuarksPdgIdVec[p-1]=MCQuarksPdgId->at(p-1);
MCQuarksMotherIdVec[p-1]=MCQuarksMotherId->at(p-1);
}
else{
MCQuarksEtaVec[p-1]=-999;
MCQuarksPhiVec[p-1]=-999;
MCQuarksPtVec[p-1]=-999;
MCQuarksEnergyVec[p-1]=-999;
MCQuarksPdgIdVec[p-1]=-999;
MCQuarksMotherIdVec[p-1]=-999;
}
}
for (size_t p = 1; p <= 4; ++p){
if(!(MCLeptonsEta->size() < p) ){
MCLeptonsEtaVec[p-1]=MCLeptonsEta->at(p-1);
MCLeptonsPhiVec[p-1]=MCLeptonsPhi->at(p-1);
MCLeptonsPtVec[p-1]=MCLeptonsPt->at(p-1);
MCLeptonsEnergyVec[p-1]=MCLeptonsEnergy->at(p-1);
MCLeptonsPdgIdVec[p-1]=MCLeptonsPdgId->at(p-1);
MCLeptonsMotherIdVec[p-1]=MCLeptonsMotherId->at(p-1);
}
else{
MCLeptonsEtaVec[p-1]=-999;
MCLeptonsPhiVec[p-1]=-999;
MCLeptonsPtVec[p-1]=-999;
MCLeptonsEnergyVec[p-1]=-999;
MCLeptonsPdgIdVec[p-1]=-999;
MCLeptonsMotherIdVec[p-1]=-999;
}
if(!(MCBQuarksEta->size() < p) ){
MCBQuarksEtaVec[p-1]=MCBQuarksEta->at(p-1);
MCBQuarksPhiVec[p-1]=MCBQuarksPhi->at(p-1);
MCBQuarksPtVec[p-1]=MCBQuarksPt->at(p-1);
MCBQuarksEnergyVec[p-1]=MCBQuarksEnergy->at(p-1);
MCBQuarksPdgIdVec[p-1]=MCBQuarksPdgId->at(p-1);
MCBQuarksMotherIdVec[p-1]=MCBQuarksMotherId->at(p-1);
}
else{
MCBQuarksEtaVec[p-1]=-999;
MCBQuarksPhiVec[p-1]=-999;
MCBQuarksPtVec[p-1]=-999;
MCBQuarksEnergyVec[p-1]=-999;
MCBQuarksPdgIdVec[p-1]=-999;
MCBQuarksMotherIdVec[p-1]=-999;
}
if(!(MCNeutrinosEta->size() < p) ){
MCNeutrinosEtaVec[p-1]=MCNeutrinosEta->at(p-1);
MCNeutrinosPhiVec[p-1]=MCNeutrinosPhi->at(p-1);
MCNeutrinosPtVec[p-1]=MCNeutrinosPt->at(p-1);
MCNeutrinosEnergyVec[p-1]=MCNeutrinosEnergy->at(p-1);
MCNeutrinosPdgIdVec[p-1]=MCNeutrinosPdgId->at(p-1);
MCNeutrinosMotherIdVec[p-1]=MCNeutrinosMotherId->at(p-1);
}
else{
MCNeutrinosEtaVec[p-1]=-999;
MCNeutrinosPhiVec[p-1]=-999;
MCNeutrinosPtVec[p-1]=-999;
MCNeutrinosEnergyVec[p-1]=-999;
MCNeutrinosPdgIdVec[p-1]=-999;
MCNeutrinosMotherIdVec[p-1]=-999;
}
}
nMCTruthLeptons = 0;
for (size_t p = 1; p <= 2; ++p){
// cout << "in loop 2" << endl;
// cout << " p is "<< p << " leptons size "<< MCTopLeptonsEta->size()<<endl;
bool isLeptonic = false;
bool isHadronic = false;
size_t position = 0;
// cout << " loop 1 "<<endl;
// cout << MCTopWsEta->size() << " p " << p<< endl;
if(isSingleTopCompHEP_){
if (MCTopLeptonsEta->size() < p)continue;
position = p;
MCTopLeptonsEtaVec[p-1]=MCTopLeptonsEta->at(position-1);
MCTopLeptonsPhiVec[p-1]=MCTopLeptonsPhi->at(position-1);
MCTopLeptonsPtVec[p-1]=MCTopLeptonsPt->at(position-1);
MCTopLeptonsEnergyVec[p-1]=MCTopLeptonsEnergy->at(position-1);
MCTopLeptonsPdgIdVec[p-1]=MCTopLeptonsPdgId->at(position-1);
MCTopLeptonsMotherIdVec[p-1]=MCTopLeptonsMotherId->at(position-1);
MCTopNeutrinosEtaVec[p-1]=MCTopNeutrinosEta->at(position-1);
MCTopNeutrinosPhiVec[p-1]=MCTopNeutrinosPhi->at(position-1);
MCTopNeutrinosPtVec[p-1]=MCTopNeutrinosPt->at(position-1);
MCTopNeutrinosEnergyVec[p-1]=MCTopNeutrinosEnergy->at(position-1);
MCTopNeutrinosPdgIdVec[p-1]=MCTopNeutrinosPdgId->at(position-1);
MCTopNeutrinosMotherIdVec[p-1]=MCTopNeutrinosMotherId->at(position-1);
if(!(MCTopBQuarksEta->size() < p) ){
MCTopBQuarksEtaVec[p-1]=MCTopBQuarksEta->at(p-1);
MCTopBQuarksPhiVec[p-1]=MCTopBQuarksPhi->at(p-1);
MCTopBQuarksPtVec[p-1]=MCTopBQuarksPt->at(p-1);
MCTopBQuarksEnergyVec[p-1]=MCTopBQuarksEnergy->at(p-1);
MCTopBQuarksPdgIdVec[p-1]=MCTopBQuarksPdgId->at(p-1);
MCTopBQuarksMotherIdVec[p-1]=MCTopBQuarksMotherId->at(p-1);
}
}
else {
if (MCTopWsEta->size() < p)continue;
if(MCTopNeutrinosEta->size()!=MCTopLeptonsEta->size())continue;
if(MCTopQuarksEta->size()!=MCTopQuarkBarsEta->size())continue;
for (size_t l = 1; l <= MCTopQuarksEta->size();++l ){
cout << " quark id "<< MCTopQuarksPdgId->at(l-1) << " quarkbar id "<< MCTopQuarkBarsPdgId->at(l-1) <<
" W dau one id "<< MCTopWsDauOneId->at(p-1) << endl;
cout << " quark mother id "<< MCTopQuarksMotherId->at(l-1) << " quarkbar id "<< MCTopQuarkBarsMotherId->at(l-1) <<
" W id "<< MCTopWsPdgId->at(p-1) << endl;
if( MCTopQuarksPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) || MCTopQuarkBarsPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) ){
position = l;
isHadronic = true;
}
}
for (size_t l = 1; l <= MCTopLeptonsEta->size();++l ){
cout << " lepton id "<< MCTopLeptonsPdgId->at(l-1) << " neutrino id "<< MCTopNeutrinosPdgId->at(l-1)<<
" W dau one id "<< MCTopWsDauOneId->at(p-1) << endl;
cout << " lepton mother id "<< MCTopLeptonsMotherId->at(l-1) << " neutrino id "<< MCTopNeutrinosMotherId->at(l-1) <<
" W id "<< MCTopWsPdgId->at(p-1) << endl;
if( MCTopLeptonsPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) || MCTopNeutrinosPdgId->at(l-1) == MCTopWsDauOneId->at(p-1) ){
position = l;
++nMCTruthLeptons;
isLeptonic = true;
}
}
cout <<" pos "<< position <<" islep "<< isLeptonic<< " lep size "<< MCTopLeptonsEta->size()<< " neu size "<< MCTopNeutrinosEta->size()<< endl;
cout <<" pos "<< position <<" ishad "<< isHadronic<< " quark size"<< MCTopQuarksEta->size()<< " qbar size "<< MCTopQuarkBarsEta->size()<< endl;
if(isLeptonic){
MCTopLeptonsEtaVec[p-1]=MCTopLeptonsEta->at(position-1);
MCTopLeptonsPhiVec[p-1]=MCTopLeptonsPhi->at(position-1);
MCTopLeptonsPtVec[p-1]=MCTopLeptonsPt->at(position-1);
MCTopLeptonsEnergyVec[p-1]=MCTopLeptonsEnergy->at(position-1);
MCTopLeptonsPdgIdVec[p-1]=MCTopLeptonsPdgId->at(position-1);
MCTopLeptonsMotherIdVec[p-1]=MCTopLeptonsMotherId->at(position-1);
MCTopNeutrinosEtaVec[p-1]=MCTopNeutrinosEta->at(position-1);
MCTopNeutrinosPhiVec[p-1]=MCTopNeutrinosPhi->at(position-1);
MCTopNeutrinosPtVec[p-1]=MCTopNeutrinosPt->at(position-1);
MCTopNeutrinosEnergyVec[p-1]=MCTopNeutrinosEnergy->at(position-1);
MCTopNeutrinosPdgIdVec[p-1]=MCTopNeutrinosPdgId->at(position-1);
MCTopNeutrinosMotherIdVec[p-1]=MCTopNeutrinosMotherId->at(position-1);
}
else{
MCTopLeptonsEtaVec[p-1]=-999;
MCTopLeptonsPhiVec[p-1]=-999;
MCTopLeptonsPtVec[p-1]=-999;
MCTopLeptonsEnergyVec[p-1]=-999;
MCTopLeptonsPdgIdVec[p-1]=-999;
MCTopLeptonsMotherIdVec[p-1]=-999;
MCTopNeutrinosEtaVec[p-1]=-999;
MCTopNeutrinosPhiVec[p-1]=-999;
MCTopNeutrinosPtVec[p-1]=-999;
MCTopNeutrinosEnergyVec[p-1]=-999;
MCTopNeutrinosPdgIdVec[p-1]=-999;
MCTopNeutrinosMotherIdVec[p-1]=-999;
}
if(isHadronic){
MCTopQuarksEtaVec[p-1]=MCTopQuarksEta->at(position-1);
MCTopQuarksPhiVec[p-1]=MCTopQuarksPhi->at(position-1);
MCTopQuarksPtVec[p-1]=MCTopQuarksPt->at(position-1);
MCTopQuarksEnergyVec[p-1]=MCTopQuarksEnergy->at(position-1);
MCTopQuarksPdgIdVec[p-1]=MCTopQuarksPdgId->at(position-1);
MCTopQuarksMotherIdVec[p-1]=MCTopQuarksMotherId->at(position-1);
MCTopQuarkBarsEtaVec[p-1]=MCTopQuarkBarsEta->at(position-1);
MCTopQuarkBarsPhiVec[p-1]=MCTopQuarkBarsPhi->at(position-1);
MCTopQuarkBarsPtVec[p-1]=MCTopQuarkBarsPt->at(position-1);
MCTopQuarkBarsEnergyVec[p-1]=MCTopQuarkBarsEnergy->at(position-1);
MCTopQuarkBarsPdgIdVec[p-1]=MCTopQuarkBarsPdgId->at(position-1);
MCTopQuarkBarsMotherIdVec[p-1]=MCTopQuarkBarsMotherId->at(position-1);
}
else{
MCTopQuarksEtaVec[p-1]=-999;
MCTopQuarksPhiVec[p-1]=-999;
MCTopQuarksPtVec[p-1]=-999;
MCTopQuarksEnergyVec[p-1]=-999;
MCTopQuarksPdgIdVec[p-1]=-999;
MCTopQuarksMotherIdVec[p-1]=-999;
MCTopQuarkBarsEtaVec[p-1]=-999;
MCTopQuarkBarsPhiVec[p-1]=-999;
MCTopQuarkBarsPtVec[p-1]=-999;
MCTopQuarkBarsEnergyVec[p-1]=-999;
MCTopQuarkBarsPdgIdVec[p-1]=-999;
MCTopQuarkBarsMotherIdVec[p-1]=-999;
}
if(!(MCTopWsEta->size() < p) ){
MCTopWsEtaVec[p-1]=MCTopWsEta->at(p-1);
MCTopWsPhiVec[p-1]=MCTopWsPhi->at(p-1);
MCTopWsPtVec[p-1]=MCTopWsPt->at(p-1);
MCTopWsEnergyVec[p-1]=MCTopWsEnergy->at(p-1);
MCTopWsPdgIdVec[p-1]=MCTopWsPdgId->at(p-1);
}
else{
MCTopWsEtaVec[p-1]=-999;
MCTopWsPhiVec[p-1]=-999;
MCTopWsPtVec[p-1]=-999;
MCTopWsEnergyVec[p-1]=-999;
MCTopWsPdgIdVec[p-1]=-999;
}
if(!(MCTopBQuarksEta->size() < p) ){
MCTopBQuarksEtaVec[p-1]=MCTopBQuarksEta->at(p-1);
MCTopBQuarksPhiVec[p-1]=MCTopBQuarksPhi->at(p-1);
MCTopBQuarksPtVec[p-1]=MCTopBQuarksPt->at(p-1);
MCTopBQuarksEnergyVec[p-1]=MCTopBQuarksEnergy->at(p-1);
MCTopBQuarksPdgIdVec[p-1]=MCTopBQuarksPdgId->at(p-1);
MCTopBQuarksMotherIdVec[p-1]=MCTopBQuarksMotherId->at(p-1);
}
else{
MCTopBQuarksEtaVec[p-1]=-999;
MCTopBQuarksPhiVec[p-1]=-999;
MCTopBQuarksPtVec[p-1]=-999;
MCTopBQuarksEnergyVec[p-1]=-999;
MCTopBQuarksPdgIdVec[p-1]=-999;
MCTopBQuarksMotherIdVec[p-1]=-999;
}
if( (!(MCBQuarksEta->size() < p)) && (!(MCTopWsEta->size() < p))){
math::PtEtaPhiELorentzVector mctop = math::PtEtaPhiELorentzVector(
(MCTopBQuarksPtVec[p-1]+MCTopWsPtVec[p-1]),
(MCTopBQuarksEtaVec[p-1]+MCTopWsEtaVec[p-1]),
(MCTopBQuarksPhiVec[p-1]+MCTopWsPhiVec[p-1]),
(MCTopBQuarksEnergyVec[p-1]+MCTopWsEnergyVec[p-1]) );
MCTopsEtaVec[p-1]=MCTopsEta->at(p-1);
MCTopsPhiVec[p-1]=MCTopsPhi->at(p-1);
MCTopsPtVec[p-1]=MCTopsPt->at(p-1);
MCTopsEnergyVec[p-1]=MCTopsEnergy->at(p-1);
MCTopsPdgIdVec[p-1]=MCTopsPdgId->at(p-1);
}
else{
MCTopsEtaVec[p-1]=-999;
MCTopsPhiVec[p-1]=-999;
MCTopsPtVec[p-1]=-999;
MCTopsEnergyVec[p-1]=-999;
MCTopsPdgIdVec[p-1]=-999;
}
}
}
}
if (nJets == 2)
{
//cout << " B is "<< B<< " syst is "<<syst_name <<endl;
//cout<< " tree name "<< trees2J[B][syst_name]->GetName() <<endl;
trees2J[B][syst_name]->Fill();
}
if (nJets == 3)
{
//cout << " B is "<< B<< " syst is "<<syst_name <<endl;
// cout << " tree name "<< trees3J[B][syst_name]->GetName() <<endl;
trees3J[B][syst_name]->Fill();
}
}
}
}
//CosThetalj given top quark, lepton and light jet
float SingleTopSystematicsTreesDumper::cosThetaLJ(math::PtEtaPhiELorentzVector lepton, math::PtEtaPhiELorentzVector jet, math::PtEtaPhiELorentzVector top)
{
math::PtEtaPhiELorentzVector boostedLepton = ROOT::Math::VectorUtil::boost(lepton, top.BoostToCM());
math::PtEtaPhiELorentzVector boostedJet = ROOT::Math::VectorUtil::boost(jet, top.BoostToCM());
return ROOT::Math::VectorUtil::CosTheta(boostedJet.Vect(), boostedLepton.Vect());
}
//CosTheta-lepton-beam-line, implementation by Joosep Pata
float SingleTopSystematicsTreesDumper::cosTheta_eta_bl(math::PtEtaPhiELorentzVector lepton, math::PtEtaPhiELorentzVector jet, math::PtEtaPhiELorentzVector top)
{
double eta = jet.eta();
double z;
if (eta > 0)
{
z = 1.0;
}
else
{
z = -1.0;
}
math::XYZTLorentzVector beamLine = math::XYZTLorentzVector(0.0, 0.0, z, 1.0);
math::PtEtaPhiELorentzVector boostedLepton = ROOT::Math::VectorUtil::boost(lepton, top.BoostToCM());
math::XYZTLorentzVector boostedBeamLine = ROOT::Math::VectorUtil::boost(beamLine, top.BoostToCM());
return ROOT::Math::VectorUtil::CosTheta(boostedBeamLine.Vect(), boostedLepton.Vect());
}
double SingleTopSystematicsTreesDumper::topMtw(math::PtEtaPhiELorentzVector lepton, math::PtEtaPhiELorentzVector jet, float metPx, float metPy)
{
math::PtEtaPhiELorentzVector lb = lepton + jet;
double mlb2 = lb.mass() * lb.mass();
double etlb = sqrt(mlb2 + lb.pt() * lb.pt());
double metPT = sqrt(metPx * metPx + metPy * metPy);
return sqrt( mlb2 + 2 * ( etlb * metPT - lb.px() * metPx - lb.py() * metPy ) );
}
//top quark 4-momentum given lepton, met and b-jet
math::PtEtaPhiELorentzVector SingleTopSystematicsTreesDumper::top4Momentum(math::PtEtaPhiELorentzVector lepton, math::PtEtaPhiELorentzVector jet, float metPx, float metPy)
{
return top4Momentum(lepton.px(), lepton.py(), lepton.pz(), lepton.energy(), jet.px(), jet.py(), jet.pz(), jet.energy(), metPx, metPy);
}
//top quark 4-momentum original function given the necessary parameters
math::PtEtaPhiELorentzVector SingleTopSystematicsTreesDumper::top4Momentum(float leptonPx, float leptonPy, float leptonPz, float leptonE, float jetPx, float jetPy, float jetPz, float jetE, float metPx, float metPy)
{
float lepton_Pt = sqrt( (leptonPx * leptonPx) + (leptonPy * leptonPy) );
math::XYZTLorentzVector neutrino = NuMomentum(leptonPx, leptonPy, leptonPz, lepton_Pt, leptonE, metPx, metPy); //.at(0);;
math::XYZTLorentzVector lep(leptonPx, leptonPy, leptonPz, leptonE);
math::XYZTLorentzVector jet(jetPx, jetPy, jetPz, jetE);
math::XYZTLorentzVector top = lep + jet + neutrino;
return math::PtEtaPhiELorentzVector(top.pt(), top.eta(), top.phi(), top.E());
}
//top neutrino 4-momentum function given the parameters
//In brief:
//Works for top->1l+1neutrino+1bjet
//Assuming all met comes from neutrino
/////What it does:
//w boson mass put to pdg value
//obtained neutrino pz from kinematics
//We get a second order equation
/////In case of two positive Delta solutions:
//we choose solution with minimum |pz|
/////In case of two negative Delta solutions:
//in such case: mtw > mw
//To solve this: put mtw = mw
//Solve the equations
//In this way we must
//drop the constraints px_Nu = MET_x and py_Nu = MET_y
//Solve this by chosing the px_Nu and py_Nu that
//minimize the distance from the MET in the px-py plane
//Such minimization can be done analytically with derivatives
//and much patience. Here we exploit such analytical minimization
/////
//More detailed inline description: work in progress!
math::XYZTLorentzVector SingleTopSystematicsTreesDumper::NuMomentum(float leptonPx, float leptonPy, float leptonPz, float leptonPt, float leptonE, float metPx, float metPy )
{
double mW = 80.399;
math::XYZTLorentzVector result;
// double Wmt = sqrt(pow(Lepton.et()+MET.pt(),2) - pow(Lepton.px()+metPx,2) - pow(leptonPy+metPy,2) );
double MisET2 = (metPx * metPx + metPy * metPy);
double mu = (mW * mW) / 2 + metPx * leptonPx + metPy * leptonPy;
double a = (mu * leptonPz) / (leptonE * leptonE - leptonPz * leptonPz);
double a2 = TMath::Power(a, 2);
double b = (TMath::Power(leptonE, 2.) * (MisET2) - TMath::Power(mu, 2.)) / (TMath::Power(leptonE, 2) - TMath::Power(leptonPz, 2));
double pz1(0), pz2(0), pznu(0);
int nNuSol(0);
math::XYZTLorentzVector p4nu_rec;
math::XYZTLorentzVector p4W_rec;
math::XYZTLorentzVector p4b_rec;
math::XYZTLorentzVector p4Top_rec;
math::XYZTLorentzVector p4lep_rec;
p4lep_rec.SetPxPyPzE(leptonPx, leptonPy, leptonPz, leptonE);
math::XYZTLorentzVector p40_rec(0, 0, 0, 0);
if (a2 - b > 0 )
{
//if(!usePositiveDeltaSolutions_)
// {
// result.push_back(p40_rec);
// return result;
// }
double root = sqrt(a2 - b);
pz1 = a + root;
pz2 = a - root;
nNuSol = 2;
// if(usePzPlusSolutions_)pznu = pz1;
// if(usePzMinusSolutions_)pznu = pz2;
//if(usePzAbsValMinimumSolutions_){
pznu = pz1;
if (fabs(pz1) > fabs(pz2)) pznu = pz2;
//}
double Enu = sqrt(MisET2 + pznu * pznu);
p4nu_rec.SetPxPyPzE(metPx, metPy, pznu, Enu);
// result =.push_back(p4nu_rec);
result = p4nu_rec;
}
else
{
// if(!useNegativeDeltaSolutions_){
//result.push_back(p40_rec);
// return result;
// }
// double xprime = sqrt(mW;
double ptlep = leptonPt, pxlep = leptonPx, pylep = leptonPy, metpx = metPx, metpy = metPy;
double EquationA = 1;
double EquationB = -3 * pylep * mW / (ptlep);
double EquationC = mW * mW * (2 * pylep * pylep) / (ptlep * ptlep) + mW * mW - 4 * pxlep * pxlep * pxlep * metpx / (ptlep * ptlep) - 4 * pxlep * pxlep * pylep * metpy / (ptlep * ptlep);
double EquationD = 4 * pxlep * pxlep * mW * metpy / (ptlep) - pylep * mW * mW * mW / ptlep;
std::vector<long double> solutions = EquationSolve<long double>((long double)EquationA, (long double)EquationB, (long double)EquationC, (long double)EquationD);
std::vector<long double> solutions2 = EquationSolve<long double>((long double)EquationA, -(long double)EquationB, (long double)EquationC, -(long double)EquationD);
double deltaMin = 14000 * 14000;
double zeroValue = -mW * mW / (4 * pxlep);
double minPx = 0;
double minPy = 0;
// std::cout<<"a "<<EquationA << " b " << EquationB <<" c "<< EquationC <<" d "<< EquationD << std::endl;
// if(usePxMinusSolutions_){
for ( int i = 0; i < (int)solutions.size(); ++i)
{
if (solutions[i] < 0 ) continue;
double p_x = (solutions[i] * solutions[i] - mW * mW) / (4 * pxlep);
double p_y = ( mW * mW * pylep + 2 * pxlep * pylep * p_x - mW * ptlep * solutions[i]) / (2 * pxlep * pxlep);
double Delta2 = (p_x - metpx) * (p_x - metpx) + (p_y - metpy) * (p_y - metpy);
// std:://cout<<"intermediate solution1 met x "<<metpx << " min px " << p_x <<" met y "<<metpy <<" min py "<< p_y << std::endl;
if (Delta2 < deltaMin && Delta2 > 0)
{
deltaMin = Delta2;
minPx = p_x;
minPy = p_y;
}
// std:://cout<<"solution1 met x "<<metpx << " min px " << minPx <<" met y "<<metpy <<" min py "<< minPy << std::endl;
}
// }
//if(usePxPlusSolutions_){
for ( int i = 0; i < (int)solutions2.size(); ++i)
{
if (solutions2[i] < 0 ) continue;
double p_x = (solutions2[i] * solutions2[i] - mW * mW) / (4 * pxlep);
double p_y = ( mW * mW * pylep + 2 * pxlep * pylep * p_x + mW * ptlep * solutions2[i]) / (2 * pxlep * pxlep);
double Delta2 = (p_x - metpx) * (p_x - metpx) + (p_y - metpy) * (p_y - metpy);
// std:://cout<<"intermediate solution2 met x "<<metpx << " min px " << minPx <<" met y "<<metpy <<" min py "<< minPy << std::endl;
if (Delta2 < deltaMin && Delta2 > 0)
{
deltaMin = Delta2;
minPx = p_x;
minPy = p_y;
}
// std:://cout<<"solution2 met x "<<metpx << " min px " << minPx <<" met y "<<metpy <<" min py "<< minPy << std::endl;
}
//}
double pyZeroValue = ( mW * mW * pxlep + 2 * pxlep * pylep * zeroValue);
double delta2ZeroValue = (zeroValue - metpx) * (zeroValue - metpx) + (pyZeroValue - metpy) * (pyZeroValue - metpy);
if (deltaMin == 14000 * 14000)return result;
// else std:://cout << " test " << std::endl;
if (delta2ZeroValue < deltaMin)
{
deltaMin = delta2ZeroValue;
minPx = zeroValue;
minPy = pyZeroValue;
}
// std:://cout<<" MtW2 from min py and min px "<< sqrt((minPy*minPy+minPx*minPx))*ptlep*2 -2*(pxlep*minPx + pylep*minPy) <<std::endl;
/// ////Y part
double mu_Minimum = (mW * mW) / 2 + minPx * pxlep + minPy * pylep;
double a_Minimum = (mu_Minimum * leptonPz) / (leptonE * leptonE - leptonPz * leptonPz);
pznu = a_Minimum;
//if(!useMetForNegativeSolutions_){
double Enu = sqrt(minPx * minPx + minPy * minPy + pznu * pznu);
p4nu_rec.SetPxPyPzE(minPx, minPy, pznu , Enu);
// }
// else{
// pznu = a;
// double Enu = sqrt(metpx*metpx+metpy*metpy + pznu*pznu);
// p4nu_rec.SetPxPyPzE(metpx, metpy, pznu , Enu);
// }
// result.push_back(p4nu_rec);
result = p4nu_rec;
}
return result;
}
//JES uncertainty as a function of pt, eta and jet flavour
double SingleTopSystematicsTreesDumper::jetUncertainty(double eta, double ptCorr, int flavour)
{
jecUnc->setJetEta(eta);
jecUnc->setJetPt(ptCorr);
double JetCorrection = jecUnc->getUncertainty(true);
return JetCorrection;
}
float SingleTopSystematicsTreesDumper::muonHLTEff(float eta, string period)
{
float eff = 0.87;
/* if(period == "Mu2012A"){
if (eta < -1.1 && eta > -2.1) eff = 0.81;
if (eta > -1.1 && eta < -0.9) eff = 0.835;
if (eta > -0.9 && eta < -0.0) eff = 0.919;
if (eta > 0.0 && eta < 0.9) eff = 0.921;
if (eta > 0.9 && eta < 1.1) eff = 0.83;
if (eta > 1.1 && eta < 2.1) eff = 0.815;
}
if(period == "Mu2012B"){
if (eta < -1.1 && eta > -2.1) eff = 0.81;
if (eta > -1.1 && eta < -0.9) eff = 0.841;
if (eta > -0.9 && eta < -0.0) eff = 0.938;
if (eta > 0.0 && eta < 0.9) eff = 0.940;
if (eta > 0.9 && eta < 1.1) eff = 0.84;
if (eta > 1.1 && eta < 2.1) eff = 0.821;
}OLD
*/
if(period == "Mu2012A"){
// if (eta < -1.2 && eta > -2.1) eff = 0.8083; if (eta > -1.2 && eta < -0.9) eff = 0.8339; if (eta > -0.9 && eta < -0.0) eff = 0.9151; if (eta > 0.0 && eta < 0.9) eff = 0.9151; if (eta > 0.9 && eta < 1.2) eff = 0.8339; if (eta > 1.2 && eta < 2.1) eff = 0.8083;
if(eta>-2.1 && eta <-1.2)eff = 0.8077;
if(eta>-1.2 && eta <-0.9)eff = 0.8573;
if(eta>-0.9 && eta < 0.9)eff = 0.9346;
if(eta> 0.9 && eta < 1.2)eff = 0.8573;
if(eta> 1.2 && eta < 2.1)eff = 0.8077;
}
if(period == "Mu2012B"){
// if (eta < -1.2 && eta > -2.1) eff = 0.8047; if (eta > -1.2 && eta < -0.9) eff = 0.8394; if (eta > -0.9 && eta < -0.0) eff = 0.9326; if (eta > 0.0 && eta < 0.9) eff = 0.9326; if (eta > 0.9 && eta < 1.2) eff = 0.8394; if (eta > 1.2 && eta < 2.1) eff = 0.8047;
if(eta>-2.1 && eta <-1.2)eff = 0.8077;
if(eta>-1.2 && eta <-0.9)eff = 0.8573;
if(eta>-0.9 && eta < 0.9)eff = 0.9346;
if(eta> 0.9 && eta < 1.2)eff = 0.8573;
if(eta> 1.2 && eta < 2.1)eff = 0.8077;
}
if(period == "Mu2012ASF"){
if(eta>-2.1 && eta <-1.2)eff = 0.9809;
if(eta>-1.2 && eta <-0.9)eff = 0.9528;
if(eta>-0.9 && eta < 0.9)eff = 0.9560;
if(eta> 0.9 && eta < 1.2)eff = 0.9528;
if(eta> 1.2 && eta < 2.1)eff = 0.9809;
}
if(period == "Mu2012BSF"){
if(eta>-2.1 && eta <-1.2)eff = 0.9814;
if(eta>-1.2 && eta <-0.9)eff = 0.9618;
if(eta>-0.9 && eta < 0.9)eff = 0.9798;
if(eta> 0.9 && eta < 1.2)eff = 0.9618;
if(eta> 1.2 && eta < 2.1)eff = 0.9814;
}
if(period == "Mu2012CSF"){
if(eta>-2.1 && eta <-1.2)eff = 1.0021;
if(eta>-1.2 && eta <-0.9)eff = 0.9688;
if(eta>-0.9 && eta < 0.9)eff = 0.9841;
if(eta> 0.9 && eta < 1.2)eff = 0.9688;
if(eta> 1.2 && eta < 2.1)eff = 1.0021;
}
return eff;
}
//EndJob filling rate systematics trees
void SingleTopSystematicsTreesDumper::endJob()
{
//part for rate systematics
cout << endl << passingLepton << " | " << passingMuonVeto << " | " << passingLeptonVeto << " | " << passingJets << " | " << passingMET << " | " << passingBJets << endl << endl;
// resetWeightsDoubles();
/* for(size_t i = 0; i < rate_systematics.size();++i){
string syst = rate_systematics[i];
string treename = (channel+"_"+syst);
cout<< " endjob" << syst<< " 0 "<<endl;
int bj =0;
trees2J[bj][syst]->CopyAddresses(trees2J[bj]["noSyst"]);
cout<< " endjob" << syst<< " 1 "<<endl;
//modify the weight by a constant factor
double tmpWeight = 0;
double weightSF = 1.;
TBranch * b = trees2J[bj]["noSyst"]->GetBranch("weight");
int entries = b->GetEntries();
b->SetAddress(&tmpWeight);
cout<< " endjob" << syst<< " 2 "<<endl;
trees2J[bj][syst]->GetBranch("weight")->Reset();
trees2J[bj][syst]->GetBranch("weight")->SetAddress(&tmpWeight);
cout<< " endjob" << syst<< " 3 "<<endl;
for(int t =0; t < entries ; ++t){
b->GetEntry(t);
tmpWeight*=weightSF;
trees2J[bj][syst]->GetBranch("weight")->Fill();
}
b->SetAddress(&weightTree);
trees2J[bj][syst]->GetBranch("weight")->SetAddress(&weightTree);
// cout<< " syst "<< syst<< " weights entries "<< entries <<endl;
}*/
}
//B-C weight as function of jet flavour, systematics and scale factors:
//WILL BE CHANGED VERY SOON ACCORDING TO NEW PRESCRIPTIONS
double SingleTopSystematicsTreesDumper::BTagSFNew(double pt, string algo)
{
if (algo == "CSVM")return 0.6981 * ((1. + (0.414063 * pt)) / (1. + (0.300155 * pt)));
if (algo == "CSVT")return 0.901615 * ((1. + (0.552628 * pt)) / (1. + (0.547195 * pt)));
if (algo == "TCHPT")return 0.305208*((1.+(0.595166*pt))/(1.+(0.186968*pt)));
//old prescription if (algo == "TCHPT")return 0.895596 * ((1. + (9.43219e-05 * pt)) / (1. + (-4.63927e-05 * pt)));
if (algo == "CSVL") return 1.02658 * ((1. + (0.0195388 * pt)) / (1. + (0.0209145 * pt)));
return 1;
}
double SingleTopSystematicsTreesDumper::BTagSFErrNew(double pt, string algo)
{
if (algo == "TCHPT")
{
// if (pt > 30 && pt < 40)return 0.0543376; if (pt > 40 && pt < 50)return 0.0534339; if (pt > 50 && pt < 60)return 0.0266156; if (pt > 60 && pt < 70)return 0.0271337; if (pt > 70 && pt < 80)return 0.0276364; if (pt > 80 && pt < 100)return 0.0308838; if (pt > 100 && pt < 120)return 0.0381656; if (pt > 120 && pt < 160)return 0.0336979; if (pt > 160 && pt < 210)return 0.0336773; if (pt > 210 && pt < 260)return 0.0347688; if (pt > 260 && pt < 320)return 0.0376865; if (pt > 320 && pt < 400)return 0.0556052; if (pt > 400 && pt < 500)return 0.0598105; if (pt > 500 && pt < 670)return 0.0861122;
if (pt > 20 && pt < 30)return 0.0725549;
if (pt > 30 && pt < 40)return 0.0275189;
if (pt > 40 && pt < 50)return 0.0279695;
if (pt > 50 && pt < 60)return 0.028065;
if (pt > 60 && pt < 70)return 0.0270752;
if (pt > 70 && pt < 80)return 0.0254934;
if (pt > 80 && pt < 100)return 0.0262087;
if (pt > 100 && pt < 120)return 0.0230919;
if (pt > 120 && pt < 160)return 0.0294829;
if (pt > 160 && pt < 210)return 0.0226487;
if (pt > 210 && pt < 260)return 0.0272755;
if (pt > 260 && pt < 320)return 0.0303747;
if (pt > 320 && pt < 400)return 0.051223;
if (pt > 400 && pt < 500)return 0.0542895;
if (pt > 500 && pt < 600)return 0.0589887;
if (pt > 600 && pt < 800)return 0.0584216;
}
if (algo == "TCHEL")
{
if (pt > 30 && pt < 40)return 0.0244956;
if (pt > 40 && pt < 50)return 0.0237293;
if (pt > 50 && pt < 60)return 0.0180131;
if (pt > 60 && pt < 70)return 0.0182411;
if (pt > 70 && pt < 80)return 0.0184592;
if (pt > 80 && pt < 100)return 0.0106444;
if (pt > 100 && pt < 120)return 0.0110736;
if (pt > 120 && pt < 160)return 0.0106296;
if (pt > 160 && pt < 210)return 0.0175259;
if (pt > 210 && pt < 260)return 0.0161566;
if (pt > 260 && pt < 320)return 0.0158973;
if (pt > 320 && pt < 400)return 0.0186782;
if (pt > 400 && pt < 500)return 0.0371113;
if (pt > 500 && pt < 670)return 0.0289788;
}
if (algo == "CSVM")
{
if (pt > 30 && pt < 40)return 0.0295675;
if (pt > 40 && pt < 50)return 0.0295095;
if (pt > 50 && pt < 60)return 0.0210867;
if (pt > 60 && pt < 70)return 0.0219349;
if (pt > 70 && pt < 80)return 0.0227033;
if (pt > 80 && pt < 100)return 0.0204062;
if (pt > 100 && pt < 120)return 0.0185857;
if (pt > 120 && pt < 160)return 0.0256242;
if (pt > 160 && pt < 210)return 0.0383341;
if (pt > 210 && pt < 260)return 0.0409675;
if (pt > 260 && pt < 320)return 0.0420284;
if (pt > 320 && pt < 400)return 0.0541299;
if (pt > 400 && pt < 500)return 0.0578761;
if (pt > 500 && pt < 670)return 0.0655432;
}
if (algo == "CSVT")
{
if (pt > 30 && pt < 40)return 0.0364717;
if (pt > 40 && pt < 50)return 0.0362281;
if (pt > 50 && pt < 60)return 0.0232876;
if (pt > 60 && pt < 70)return 0.0249618;
if (pt > 70 && pt < 80)return 0.0261482;
if (pt > 80 && pt < 100)return 0.0290466;
if (pt > 100 && pt < 120)return 0.0300033;
if (pt > 120 && pt < 160)return 0.0453252;
if (pt > 160 && pt < 210)return 0.0685143;
if (pt > 210 && pt < 260)return 0.0653621;
if (pt > 260 && pt < 320)return 0.0712586;
if (pt > 320 && pt < 400)return 0.0945892;
if (pt > 400 && pt < 500)return 0.0777011;
if (pt > 500 && pt < 670)return 0.0866563;
}
if (algo == "CSVL")
{
if (pt > 30 && pt < 40)return 0.0188743;
if (pt > 40 && pt < 50)return 0.0161816;
if (pt > 50 && pt < 60)return 0.0139824;
if (pt > 60 && pt < 70)return 0.0152644;
if (pt > 70 && pt < 80)return 0.0161226;
if (pt > 80 && pt < 100)return 0.0157396;
if (pt > 100 && pt < 120)return 0.0161619;
if (pt > 120 && pt < 160)return 0.0168747;
if (pt > 160 && pt < 210)return 0.0257175;
if (pt > 210 && pt < 260)return 0.026424;
if (pt > 260 && pt < 320)return 0.0264928;
if (pt > 320 && pt < 400)return 0.0315127;
if (pt > 400 && pt < 500)return 0.030734;
if (pt > 500 && pt < 670)return 0.0438259 ;
}
return 0;
}
double SingleTopSystematicsTreesDumper::MisTagSFNew(double pt, double eta, string algo)
{
if (algo == "TCHPT")return ((1.1676+(0.00136673*pt))+(-3.51053e-06*(pt*pt)))+(2.4966e-09*(pt*(pt*pt)));
if (algo == "CSVM")return ((1.20711 + (0.000681067 * pt)) + (-1.57062e-06 * (pt * pt))) + (2.83138e-10 * (pt * (pt * pt))) * (1.10422 + -0.000523856 * pt + 1.14251e-06 * pt * pt);
if (algo == "CSVT") return (1.10649 * ((1 + (-9.00297e-05 * pt)) + (2.32185e-07 * (pt * pt)))) + (-4.04925e-10 * (pt * (pt * (pt / (1 + (-0.00051036 * pt)))))) * (1.19275 + -0.00191042 * pt + 2.92205e-06 * pt * pt);
if (algo == "CSVL")return ((1.0344 + (0.000962994 * pt)) + (-3.65392e-06 * (pt * pt))) + (3.23525e-09 * (pt * (pt * pt))) * (0.979396 + 0.000205898 * pt + 2.49868e-07 * pt * pt);
return 0;
}
double SingleTopSystematicsTreesDumper::MisTagSFErrNewUp(double pt, double eta, string algo)
{
double x = pt;
if (algo == "TCHPT")return ((1.34691+(0.00181637*pt))+(-4.64484e-06*(pt*pt)))+(3.27122e-09*(pt*(pt*pt)));
if (algo == "TCHEL")return (1.19751 * ((1 + (-0.000114197 * pt)) + (3.08558e-07 * (pt * pt)))) + (-5.27598e-10 * (pt * (pt * (pt / (1 + (-0.000422372 * pt)))))) ;
if (algo == "CSVT") return ((0.997077 + (0.00473953 * x)) + (-1.34985e-05 * (x * x))) + (1.0032e-08 * (x * (x * x)));
if (algo == "CSVL")return ((1.11272 + (0.00110104 * x)) + (-4.11956e-06 * (x * x))) + (3.65263e-09 * (x * (x * x)));
return 0;
}
double SingleTopSystematicsTreesDumper::MisTagSFErrNewDown(double pt, double eta, string algo)
{
double x = pt;
if (algo == "TCHPT")return ((0.988346+(0.000914722*pt))+(-2.37077e-06*(pt*pt)))+(1.72082e-09*(pt*(pt*pt)));
if (algo == "TCHEL")return (1.01541 * ((1 + (-6.04627e-05 * pt)) + (1.38195e-07 * (pt * pt)))) + (-2.83043e-10 * (pt * (pt * (pt / (1 + (-0.000633609 * pt))))));
if (algo == "CSVT") return ((0.899715 + (0.00102278 * x)) + (-2.46335e-06 * (x * x))) + (9.71143e-10 * (x * (x * x)));
if (algo == "CSVL")return ((0.956023 + (0.000825106 * x)) + (-3.18828e-06 * (x * x))) + (2.81787e-09 * (x * (x * x)));
return 0;
}
double SingleTopSystematicsTreesDumper::EFFMapNew(double btag, string algo)
{
if (algo == "TCHP_B")return 1.26119661124e-05 * btag * btag * btag * btag + -0.000683198597977 * btag * btag * btag + 0.0145106168149 * btag * btag + -0.159575511553 * btag + 0.887707865272;
if (algo == "TCHP_C")
{
if (btag < 0.54) return 0.451288118581 * exp(-0.0213290505241 * btag * btag * btag + 0.356020789904 * btag * btag + -2.20158883207 * btag + 1.84838018633 );
else return 0.99;
}
if (algo == "TCHP_L")return (-0.00101 + (4.70405e-05 * btag)) + (8.3338e-09 * (btag * btag));
if (algo == "TCHE_B")return 3.90732786802e-06 * btag * btag * btag * btag + -0.000239934437355 * btag * btag * btag + 0.00664986827287 * btag * btag + -0.112578996016 * btag + 1.00775721404;
if (algo == "TCHE_C")
{
if (btag > 0.46 ) return 0.343760640168 * exp(-0.00315525164823 * btag * btag * btag + 0.0805427315196 * btag * btag + -0.867625139194 * btag + 1.44815935164 );
else return 0.99;//EFFMap("TCHEL_C");
}
if (algo == "TCHE_L")return(((-0.0276197 + (0.00291907 * btag)) + (-7.51594e-06 * (btag * btag))) + (9.82128e-09 * (btag * (btag * btag)))) + (-5.33759e-12 * (btag * (btag * (btag * btag))));
return 1;
}
double SingleTopSystematicsTreesDumper::EFFMap(string algo )
{
if (algo == "TCHPT_B")return 0.365 * 1.;
if (algo == "TCHPT_C")return 0.0365;
if (algo == "TCHPT_L")return 0.0017;
if (algo == "CSVT_B")return 0.5;
if (algo == "CSVT_C")return 0.05;
if (algo == "CSVT_L")return 0.003;
if (algo == "CSVM_B")return 0.365;
if (algo == "CSVM_C")return 0.0365;
if (algo == "CSVM_L")return 0.0017;
if (algo == "CSVL_B")return 0.8;
if (algo == "CSVL_C")return 0.36;
if (algo == "CSVL_L")return 0.2;
return 0.36;
}
double SingleTopSystematicsTreesDumper::EFFMap(string algo, string channel )
{
if (channel == "TChannel" || channel == "TbarChannel" || channel == "SChannel" || channel == "SbarChannel" || channel == "TWChannel" || channel == "TbarWChannel")
{
if (algo == "CSVT_B")return 0.54;
if (algo == "CSVT_C")return 0.037;
if (algo == "CSVT_L")return 0.002;
if (algo == "CSVL_B")return 0.84;
if (algo == "CSVL_C")return 0.33;
if (algo == "CSVL_L")return 0.2;
}
if (channel == "TTBar")
{
if (algo == "CSVT_B")return 0.66;
if (algo == "CSVT_C")return 0.052;
if (algo == "CSVT_L")return 0.047;
if (algo == "CSVL_B")return 0.92;
if (algo == "CSVL_C")return 0.44;
if (algo == "CSVL_L")return 0.3;
}
if (channel == "WJets")
{
if (algo == "CSVT_B")return 0.31;
if (algo == "CSVT_C")return 0.046;
if (algo == "CSVT_L")return 0.0015;
if (algo == "CSVL_B")return 0.63;
if (algo == "CSVL_C")return 0.40;
if (algo == "CSVL_L")return 0.14;
}
if (channel == "ZJets")
{
if (algo == "CSVT_B")return 0.41;
if (algo == "CSVT_C")return 0.047;
if (algo == "CSVT_L")return 0.002;
if (algo == "CSVL_B")return 0.76;
if (algo == "CSVL_C")return 0.41;
if (algo == "CSVL_L")return 0.2;
}
return EFFMap(algo);
}
double SingleTopSystematicsTreesDumper::EFFErrMap(string algo )
{
if (algo == "TCHPT_B")return 0.05;
if (algo == "TCHPT_C")return 0.05;
if (algo == "TCHPT_L")return 0.0004;
if (algo == "TCHEL_B")return 0.05;
if (algo == "TCHEL_C")return 0.05;
if (algo == "TCHEL_L")return 0.03;
if (algo == "TCHEL_B")return 0.05;
if (algo == "TCHEL_C")return 0.05;
if (algo == "TCHEL_L")return 0.004;
return 0.05;
}
double SingleTopSystematicsTreesDumper::turnOnWeight (std::vector<double> probabilities, int njets_req = 1)
{
double prob = 0;
for (unsigned int i = 0; i < pow(2, probabilities.size()); ++i)
{
//at least njets_req objects for trigger required
int ntrigobj = 0;
for (unsigned int j = 0; j < probabilities.size(); ++j)
{
if ((int)(i / pow(2, j)) % 2) ntrigobj++;
}
if (ntrigobj < njets_req) continue;
double newprob = 1;
for (unsigned int j = 0; j < probabilities.size(); ++j)
{
if ((int)(i / pow(2, j)) % 2) newprob *= probabilities[j];
else newprob *= 1 - probabilities[j];
}
prob += newprob;
}
return prob;
}
int SingleTopSystematicsTreesDumper::eventFlavour(string ch, int nb, int nc, int nl)
{
if (ch != "WJets" && ch != "ZJets") return 0;
else
{
if ( flavourFilter("WJets_wlight", nb, nc, nl) ) return 1;
if ( flavourFilter("WJets_wcc", nb, nc, nl) ) return 2;
if ( flavourFilter("WJets_wbb", nb, nc, nl) ) return 3;
}
return 0;
}
bool SingleTopSystematicsTreesDumper::flavourFilter(string ch, int nb, int nc, int nl)
{
if (ch == "WJets_wbb" || ch == "ZJets_wbb") return (nb > 0 );
if (ch == "WJets_wcc" || ch == "ZJets_wcc") return (nb == 0 && nc > 0);
if (ch == "WJets_wlight" || ch == "ZJets_wlight") return (nb == 0 && nc == 0);
return true;
}
/*double SingleTopSystematicsTreesDumper::jetprob(double pt, double btag){
double prob=0.993*(exp(-51.0*exp(-0.160*pt)));
prob*=0.902*exp((-5.995*exp(-0.604*btag)));
return prob;
}*/
double SingleTopSystematicsTreesDumper::jetprob(double pt, double btag)
{
double prob = 0.982 * exp(-30.6 * exp(-0.151 * pt)); //PT turnOn
prob *= 0.844 * exp((-6.72 * exp(-0.720 * btag))); //BTag turnOn
return prob;
}
double SingleTopSystematicsTreesDumper::jetprobpt(double pt)
{
double prob = 0.982 * exp(-30.6 * exp(-0.151 * pt)); //PT turnOn
return prob;
}
double SingleTopSystematicsTreesDumper::jetprobbtag(double btag)
{
double prob = 0.844 * exp((-6.72 * exp(-0.720 * btag))); //BTag turnOn
return prob;
}
double SingleTopSystematicsTreesDumper::turnOnProbs(string syst, int n)
{
if(doTurnOn_)return 1.0;
if (syst == "JetTrig1Up")
{
return turnOnWeight(jetprobs_j1up, 1)
;
}
else if (syst == "JetTrig2Up")
{
return turnOnWeight(jetprobs_j2up, 1)
;
}
else if (syst == "JetTrig3Up")
{
return turnOnWeight(jetprobs_j3up, 1)
;
}
if (syst == "JetTrig1Down")
{
return turnOnWeight(jetprobs_j1down, 1)
;
}
else if (syst == "JetTrig2Down")
{
return turnOnWeight(jetprobs_j2down, 1)
;
}
else if (syst == "JetTrig3Down")
{
return turnOnWeight(jetprobs_j3down, 1)
;
}
if (syst == "BTagTrig1Up")
{
return turnOnWeight(jetprobs_b1up, 1)
;
}
else if (syst == "BTagTrig2Up")
{
return turnOnWeight(jetprobs_b2up, 1)
;
}
else if (syst == "BTagTrig3Up")
{
return turnOnWeight(jetprobs_b3up, 1)
;
}
if (syst == "BTagTrig1Down")
{
return turnOnWeight(jetprobs_b1down, 1)
;
}
else if (syst == "BTagTrig2Down")
{
return turnOnWeight(jetprobs_b2down, 1)
;
}
else if (syst == "BTagTrig3Down")
{
return turnOnWeight(jetprobs_b3down, 1)
;
}
return turnOnWeight(jetprobs, 1);
}
void SingleTopSystematicsTreesDumper::pushJetProbs(double pt, double btag, double eta)
{
jetprobs.push_back(jetprob(pt, btag, eta, "noSyst"));
jetprobs_j1up.push_back(jetprob(pt, btag, eta, "JetTrig1Up"));
jetprobs_j1down.push_back(jetprob(pt, btag, eta, "JetTrig1Down"));
jetprobs_j2up.push_back(jetprob(pt, btag, eta, "JetTrig2Up"));
jetprobs_j2down.push_back(jetprob(pt, btag, eta, "JetTrig2Down"));
jetprobs_j3up.push_back(jetprob(pt, btag, eta, "JetTrig3Up"));
jetprobs_j3down.push_back(jetprob(pt, btag, eta, "JetTrig3Down"));
jetprobs_b1up.push_back(jetprob(pt, btag, eta, "BTagTrig1Up"));
jetprobs_b1down.push_back(jetprob(pt, btag, eta, "BTagTrig1Down"));
jetprobs_b2up.push_back(jetprob(pt, btag, eta, "BTagTrig2Up"));
jetprobs_b2down.push_back(jetprob(pt, btag, eta, "BTagTrig2Down"));
jetprobs_b3up.push_back(jetprob(pt, btag, eta, "BTagTrig3Up"));
jetprobs_b3down.push_back(jetprob(pt, btag, eta, "BTagTrig3Down"));
}
void SingleTopSystematicsTreesDumper::InitializeTurnOnReWeight(string rootFile = "CentralJet30BTagIP_2ndSF_mu.root")
{
TFile f("CentralJet30BTagIP_2ndSF_mu.root");
TH2D *histSF = dynamic_cast<TH2D *>(f.Get("ScaleFactor"));
histoSFs = *histSF;
f.Close();
// cout << " histo random test bin " <<histoSFs.FindFixBin(61,6.5)<< " content "<<histoSFs.GetBinContent(histoSFs.FindFixBin(61,6.5)) << endl;
// for
// recorrection_weights[7][7];
// float pt_bin_extremes[8];
//float tchpt_bin_extremes[8];
;
}
double SingleTopSystematicsTreesDumper::turnOnReWeight (double preWeight, double pt, double tchpt)
{
// cout << "reweight pt" << pt << " tchpt " << tchpt << endl;
// cout << " bin " << histoSFs.FindFixBin(pt, tchpt) << " sf ";
// cout << histoSFs.GetBinContent(histoSFs.FindFixBin(pt, tchpt)) << endl;
double a = histoSFs.GetBinContent(histoSFs.FindFixBin(pt, tchpt));
return a;
// return 1;//preWeight;
}
double SingleTopSystematicsTreesDumper::jetprob(double pt, double btag, double eta, string syst)
{
double prob = 1.;
if (fabs(eta) > 2.6) return 0.;
double a = 0, b = 1, c = 1;
if (syst == "BTagTrig1Up")
{
if (btag < -10.)
{
a = 0.0142;
b = -27.7;
c = -0.128;
};
if (btag > -10. && btag < -4)
{
a = 0.0735;
b = -4.24;
c = -0.0615;
};
if (btag > -4. && btag < 0.0)
{
a = 0.0196;
b = -7.71;
c = -0.0647;
};
if (btag > 0. && btag < 1.0)
{
a = 0.027;
b = -16.3;
c = -0.0933;
};
if (btag > 1. && btag < 2.0)
{
a = 0.071;
b = -50.;
c = -0.138;
};
if (btag > 2. && btag < 2.4)
{
a = 0.255;
b = -109.4;
c = -0.172;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.39;
b = -112.;
c = -0.168;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.534;
b = -113.;
c = -0.166;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.647;
b = -69.3;
c = -0.15;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.734;
b = -107;
c = -0.164;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.816;
b = -102;
c = -0.162;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.868;
b = -96.2;
c = -0.158;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.878;
b = -111;
c = -0.165;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.893;
b = -83.9;
c = -0.156;
};
if (btag > 10.0 )
{
a = 0.886;
b = -59.6;
c = -0.141;
};
}
else if (syst == "BTagTrig1Down")
{
if (btag < -10.)
{
a = 0.0138;
b = -45.4;
c = -0.146;
};
if (btag > -10. && btag < -4)
{
a = 0.065;
b = -14.6;
c = -0.104;
};
if (btag > -4. && btag < 0.0)
{
a = 0.019;
b = -9.33;
c = -0.0719;
};
if (btag > 0. && btag < 1.0)
{
a = 0.0266;
b = -20.7;
c = -0.0102;
};
if (btag > 1. && btag < 2.0)
{
a = 0.0706;
b = -65.1;
c = -0.147;
};
if (btag > 2. && btag < 2.4)
{
a = 0.253;
b = -192.;
c = -0.191;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.387;
b = -192.;
c = -0.186;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.529;
b = -188.;
c = -0.183;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.642;
b = -106.;
c = -0.164;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.73;
b = -161.;
c = -0.179;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.813;
b = -129.;
c = -0.17;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.865;
b = -123.;
c = -0.166;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.881;
b = -151.;
c = -0.176;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.891;
b = -103.;
c = -0.162;
};
if (btag > 10.0 )
{
a = 0.885;
b = -70.6;
c = -0.146;
};
}
else if (syst == "BTagTrig2Up")
{
if (btag < -10.)
{
a = 0.0141;
b = -36.5;
c = -0.136;
};
if (btag > -10. && btag < -4)
{
a = 0.0727;
b = -9.42;
c = -0.0797;
};
if (btag > -4. && btag < 0.0)
{
a = 0.0195;
b = -8.52;
c = -0.0677;
};
if (btag > 0. && btag < 1.0)
{
a = 0.027;
b = -18.5;
c = -0.0969;
};
if (btag > 1. && btag < 2.0)
{
a = 0.071;
b = -57.5;
c = -0.142;
};
if (btag > 2. && btag < 2.4)
{
a = 0.256;
b = -150.;
c = -0.181;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.392;
b = -152.;
c = -0.176;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.536;
b = -151.;
c = -0.174;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.649;
b = -87.5;
c = -0.156;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.737;
b = -134.0;
c = -0.171;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.818;
b = -115.;
c = -0.166;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.869;
b = -110.;
c = -0.162;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.883;
b = -131.;
c = -0.171;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.894;
b = -93.4;
c = -0.159;
};
if (btag > 10.0 )
{
a = 0.887;
b = -65.1;
c = -0.144;
};
}
else if (syst == "BTagTrig2Down")
{
if (btag < -10.)
{
a = 0.0138;
b = -36.5;
c = -0.138;
};
if (btag > -10. && btag < -4)
{
a = 0.0658;
b = -9.42;
c = -0.0859;
};
if (btag > -4. && btag < 0.0)
{
a = 0.0191;
b = -8.52;
c = -0.0689;
};
if (btag > 0. && btag < 1.0)
{
a = 0.0267;
b = -18.5;
c = -0.098;
};
if (btag > 1. && btag < 2.0)
{
a = 0.0706;
b = -57.5;
c = -0.144;
};
if (btag > 2. && btag < 2.4)
{
a = 0.252;
b = -150;
c = -0.182;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.384;
b = -152.;
c = -0.177;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.527;
b = -151.;
c = -0.175;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.639;
b = -87.5;
c = -0.157;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.727;
b = -134.0;
c = -0.172;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.812;
b = -115.;
c = -0.166;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.863;
b = -110.;
c = -0.162;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.877;
b = -131.;
c = -0.170;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.89;
b = -93.4;
c = -0.159;
};
if (btag > 10.0 )
{
a = 0.884;
b = -65.1;
c = -0.144;
};
}
else if (syst == "BTagTrig3Up")
{
if (btag < -10.)
{
a = 0.0139;
b = -36.5;
c = -0.137;
};
if (btag > -10. && btag < -4)
{
a = 0.0702;
b = -9.42;
c = -0.0839;
};
if (btag > -4. && btag < 0.0)
{
a = 0.0192;
b = -8.52;
c = -0.0683;
};
if (btag > 0. && btag < 1.0)
{
a = 0.0267;
b = -18.5;
c = -0.0974;
};
if (btag > 1. && btag < 2.0)
{
a = 0.0705;
b = -57.5;
c = -0.143;
};
if (btag > 2. && btag < 2.4)
{
a = 0.254;
b = -150.;
c = -0.183;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.388;
b = -152.;
c = -0.178;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.531;
b = -151.;
c = -0.175;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.644;
b = -87.5;
c = -0.158;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.732;
b = -134.0;
c = -0.172;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.815;
b = -115.;
c = -0.166;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.866;
b = -110.;
c = -0.163;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.880;
b = -131.;
c = -0.171;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.892;
b = -93.4;
c = -0.160;
};
if (btag > 10.0 )
{
a = 0.886;
b = -65.1;
c = -0.144;
};
}
else if (syst == "BTagTrig3Down")
{
if (btag < -10.)
{
a = 0.0141;
b = -36.5;
c = -0.137;
};
if (btag > -10. && btag < -4)
{
a = 0.0683;
b = -9.42;
c = -0.0817;
};
if (btag > -4. && btag < 0.0)
{
a = 0.0194;
b = -8.52;
c = -0.0684;
};
if (btag > 0. && btag < 1.0)
{
a = 0.027;
b = -18.5;
c = -0.0975;
};
if (btag > 1. && btag < 2.0)
{
a = 0.0711;
b = -57.5;
c = -0.143;
};
if (btag > 2. && btag < 2.4)
{
a = 0.253;
b = -150.;
c = -0.18;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.388;
b = -152.;
c = -0.176;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.531;
b = -151.;
c = -0.174;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.644;
b = -87.5;
c = -0.156;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.732;
b = -134.0;
c = -0.171;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.815;
b = -115.;
c = -0.165;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.866;
b = -110.;
c = -0.162;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.880;
b = -131.;
c = -0.170;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.892;
b = -93.4;
c = -0.159;
};
if (btag > 10.0 )
{
a = 0.886;
b = -65.11;
c = -0.143;
};
}
else
{
if (btag < -10.)
{
a = 0.014;
b = -36.55;
c = -0.137;
};
if (btag > -10. && btag < -4)
{
a = 0.069;
b = -9.42;
c = -0.083;
};
if (btag > -4. && btag < 0.0)
{
a = 0.019;
b = -8.52;
c = -0.068;
};
if (btag > 0. && btag < 1.0)
{
a = 0.027;
b = -18.51;
c = -0.097;
};
if (btag > 1. && btag < 2.0)
{
a = 0.071;
b = -57.54;
c = -0.143;
};
if (btag > 2. && btag < 2.4)
{
a = 0.254;
b = -150.48;
c = -0.182;
};
if (btag > 2.4 && btag < 2.8)
{
a = 0.388;
b = -151.97;
c = -0.177;
};
if (btag > 2.8 && btag < 3.2)
{
a = 0.531;
b = -150.73;
c = -0.175;
};
if (btag > 3.2 && btag < 3.6)
{
a = 0.644;
b = -87.52;
c = -0.157;
};
if (btag > 3.6 && btag < 4.0)
{
a = 0.732;
b = -134.05;
c = -0.172;
};
if (btag > 4.0 && btag < 5.0)
{
a = 0.815;
b = -115.25;
c = -0.166;
};
if (btag > 5.0 && btag < 6.0)
{
a = 0.866;
b = -109.53;
c = -0.162;
};
if (btag > 6.0 && btag < 7.0)
{
a = 0.880;
b = -130.84;
c = -0.170;
};
if (btag > 7.0 && btag < 10.0)
{
a = 0.892;
b = -93.41;
c = -0.159;
};
if (btag > 10.0 )
{
a = 0.886;
b = -65.11;
c = -0.144;
};
}
prob = a * exp(b * exp(c * pt));
return prob;
}
double SingleTopSystematicsTreesDumper::jetprobold(double pt, double btag, double eta, string syst)
{
double prob = 1.;
if (fabs(eta) > 2.6) return 0.;
//PT turnOn
if (syst == "JetTrig1Up")
{
if (eta < -1.4)prob = 0.981 * exp(-37.49 * exp(-0.158 * pt));
if (eta > -1.4 && eta < 0)prob = 0.982 * exp(-27.51 * exp(-0.146 * pt));
if (eta < 1.4 && eta > 0)prob = 0.982 * exp(-26.63 * exp(-0.145 * pt));
if (eta > 1.4)prob = 0.984 * exp(-42.17 * exp(-0.158 * pt));
;
}
else if (syst == "JetTrig2Up")
{
if (eta < -1.4)prob = 0.982 * exp(-41.17 * exp(-0.161 * pt));
if (eta > -1.4 && eta < 0)prob = 0.983 * exp(-27.03 * exp(-0.147 * pt));
if (eta < 1.4 && eta > 0)prob = 0.983 * exp(-26.18 * exp(-0.146 * pt));
if (eta > 1.4)prob = 0.986 * exp(-45.11 * exp(-0.161 * pt));
;
}
else if (syst == "JetTrig3Up")
{
if (eta < -1.4)prob = 0.981 * exp(-41.17 * exp(-0.162 * pt));
if (eta > -1.4 && eta < 0)prob = 0.982 * exp(-27.03 * exp(-0.146 * pt));
if (eta < 1.4 && eta > 0)prob = 0.982 * exp(-26.18 * exp(-0.146 * pt));
if (eta > 1.4)prob = 0.985 * exp(-45.11 * exp(-0.161 * pt));
prob = 0.982 * exp(-30.6 * exp(-0.151 * pt));
;
}
else if (syst == "JetTrig1Down")
{
if (eta < -1.4)prob = 0.981 * exp(-44.84 * exp(-0.164 * pt));
if (eta > -1.4 && eta < 0)prob = 0.982 * exp(-26.56 * exp(-0.147 * pt));
if (eta < 1.4 && eta > 0)prob = 0.983 * exp(-25.72 * exp(-0.147 * pt));
if (eta > 1.4)prob = 0.985 * exp(-48.05 * exp(-0.164 * pt))
;
}
else if (syst == "JetTrig2Down")
{
if (eta < -1.4)prob = 0.98 * exp(-41.17 * exp(-0.161 * pt));
if (eta > -1.4 && eta < 0)prob = 0.982 * exp(-27.03 * exp(-0.147 * pt));
if (eta < 1.4 && eta > 0)prob = 0.982 * exp(-26.18 * exp(-0.146 * pt));
if (eta > 1.4)prob = 0.984 * exp(-45.11 * exp(-0.161 * pt));
;
}
else if (syst == "JetTrig3Down")
{
if (eta < -1.4)prob = 0.981 * exp(-41.17 * exp(-0.161 * pt));
if (eta > -1.4 && eta < 0)prob = 0.982 * exp(-27.03 * exp(-0.147 * pt));
if (eta < 1.4 && eta > 0)prob = 0.982 * exp(-26.18 * exp(-0.146 * pt));
if (eta > 1.4)prob = 0.985 * exp(-45.11 * exp(-0.16 * pt));
;
}
else prob = 0.982 * exp(-30.6 * exp(-0.151 * pt));
//BTag turnOn
if (syst == "BTagTrig1Up")
{
prob *= 0.85 * exp(-6.35 * exp(-0.681 * btag));
}
else if (syst == "BTagTrig1Down")
{
prob *= 0.839 * exp(-7.1 * exp(-0.759 * btag));
}
else if (syst == "BTagTrig2Up")
{
prob *= 0.824 * exp(-6.72 * exp(-0.733 * btag));
}
else if (syst == "BTagTrig2Down")
{
prob *= 0.865 * exp(-6.73 * exp(-0.707 * btag));
}
else if (syst == "BTagTrig3Up")
{
prob *= 0.838 * exp(-6.73 * exp(-0.71 * btag));
}
else if (syst == "BTagTrig3Down")
{
prob *= 0.851 * exp(-6.72 * exp(-0.73 * btag));
}
else prob *= 0.844 * exp((-6.72 * exp(-0.720 * btag)));
return prob;
}
double SingleTopSystematicsTreesDumper::bTagSF(int B)
{
if (doBTagSF_ == false )return 1.0;
if (algo_ == "TCHPT")
{
if (B == 0 || B == 3)
{
return b_tchpt_0_tags.weight(jsfshpt, ntchpt_tags); //*b_tchel_0_tags.weight(jsfshel,ntchel_tags);
}
if (B == 1 || B == 4)
{
return b_tchpt_1_tag.weight(jsfshpt, ntchpt_tags);
}
if (B == 2 || B == 5)
{
return b_tchpt_2_tags.weight(jsfshpt, ntchpt_tags);
}
}
if(doLooseBJetVeto_){
if(B==1 || B == 4) return b_csvt_1_tag.weightWithVeto(jsfscsvt,ncsvt_tags,jsfscsvm,ncsvl_tags);
}
if (B == 0 || B == 3)
{
return b_csvt_0_tags.weight(jsfscsvt, ncsvt_tags); //*b_tchel_0_tags.weight(jsfshel,ntchel_tags);
}
if (B == 1 || B == 4)
{
return b_csvt_1_tag.weight(jsfscsvt, ncsvt_tags);
}
if (B == 2 || B == 5)
{
return b_csvt_2_tags.weight(jsfscsvt, ncsvt_tags);
}
return 1.;
}
double SingleTopSystematicsTreesDumper::bTagSF(int B, string syst)
{
if (doBTagSF_ == false )return 1.0;
// cout<< " B " << " ntchhpt "<< ntchpt_tags << " jsfshpt size "<<
// jsfshpt.size() << " ntchel " << ntchel_tags<< " jsfshel size " << jsfshel.size()<<endl;
if (algo_ == "TCHPT")
{
if (B == 0 || B == 3)
{
if (syst == "BTagUp") return b_tchpt_0_tags.weight(jsfshpt_b_tag_up, ntchpt_tags); //*b_tchel_0_tags.weight(jsfshel_b_tag_up,ntchel_tags);
if (syst == "BTagDown") return b_tchpt_0_tags.weight(jsfshpt_b_tag_down, ntchpt_tags); //*b_tchel_0_tags.weight(jsfshel_b_tag_down,ntchel_tags);
if (syst == "MisTagUp") return b_tchpt_0_tags.weight(jsfshpt_mis_tag_up, ntchpt_tags); //*b_tchel_0_tags.weight(jsfshel_mis_tag_up,ntchel_tags);
if (syst == "MisTagDown") return b_tchpt_0_tags.weight(jsfshpt_mis_tag_down, ntchpt_tags); //*b_tchel_0_tags.weight(jsfshel_mis_tag_down,ntchel_tags);
return b_tchpt_0_tags.weight(jsfshpt, ntchpt_tags); //*b_tchel_0_tags.weight(jsfshel,ntchel_tags);
}
if (B == 1 || B == 4)
{
if (syst == "BTagUp") return b_tchpt_1_tag.weight(jsfshpt_b_tag_up, ntchpt_tags);
if (syst == "BTagDown") return b_tchpt_1_tag.weight(jsfshpt_b_tag_down, ntchpt_tags);
if (syst == "MisTagUp") return b_tchpt_1_tag.weight(jsfshpt_mis_tag_up, ntchpt_tags);
if (syst == "MisTagDown") return b_tchpt_1_tag.weight(jsfshpt_mis_tag_down, ntchpt_tags);
return b_tchpt_1_tag.weight(jsfshpt, ntchpt_tags);
}
if (B == 2 || B == 5)
{
if (syst == "BTagUp") return b_tchpt_2_tags.weight(jsfshpt_b_tag_up, ntchpt_tags);
if (syst == "BTagDown") return b_tchpt_2_tags.weight(jsfshpt_b_tag_down, ntchpt_tags);
if (syst == "MisTagUp") return b_tchpt_2_tags.weight(jsfshpt_mis_tag_up, ntchpt_tags);
if (syst == "MisTagDown") return b_tchpt_2_tags.weight(jsfshpt_mis_tag_down, ntchpt_tags);
return b_tchpt_2_tags.weight(jsfshpt, ntchpt_tags);
}
}
//Loose jet veto:
if(doLooseBJetVeto_){
if (B == 1 || B == 4)
{
// if(syst ) return b_csvt_1_tag.weightWithVeto(jsfscsvt,ncsvt_tags,jsfscsvm,ncsvl_tags);
if (syst == "BTagUp") return b_csvt_1_tag.weightWithVeto(jsfscsvt_b_tag_up, ncsvt_tags,jsfscsvm_b_tag_up, ncsvl_tags);
if (syst == "BTagDown") return b_csvt_1_tag.weightWithVeto(jsfscsvt_b_tag_down, ncsvt_tags,jsfscsvm_b_tag_down, ncsvl_tags);
if (syst == "MisTagUp") return b_csvt_1_tag.weightWithVeto(jsfscsvt_mis_tag_up, ncsvt_tags,jsfscsvm_mis_tag_up, ncsvl_tags);
if (syst == "MisTagDown") return b_csvt_1_tag.weightWithVeto(jsfscsvt_mis_tag_down, ncsvt_tags,jsfscsvm_mis_tag_down, ncsvl_tags);
return b_csvt_1_tag.weightWithVeto(jsfscsvt,ncsvt_tags,jsfscsvm,ncsvl_tags);
}
}
//Default case: use csvt
if (B == 0 || B == 3)
{
if (syst == "BTagUp") return b_csvt_0_tags.weight(jsfscsvt_b_tag_up, ncsvt_tags); //*b_tchel_0_tags.weight(jsfshel_b_tag_up,ntchel_tags);
if (syst == "BTagDown") return b_csvt_0_tags.weight(jsfscsvt_b_tag_down, ncsvt_tags); //*b_tchel_0_tags.weight(jsfshel_b_tag_down,ntchel_tags);
if (syst == "MisTagUp") return b_csvt_0_tags.weight(jsfscsvt_mis_tag_up, ncsvt_tags); //*b_tchel_0_tags.weight(jsfshel_mis_tag_up,ntchel_tags);
if (syst == "MisTagDown") return b_csvt_0_tags.weight(jsfscsvt_mis_tag_down, ncsvt_tags); //*b_tchel_0_tags.weight(jsfshel_mis_tag_down,ntchel_tags);
return b_csvt_0_tags.weight(jsfscsvt, ncsvt_tags); //*b_tchel_0_tags.weight(jsfshel,ntchel_tags);
}
if (B == 1 || B == 4)
{
if (syst == "BTagUp") return b_csvt_1_tag.weight(jsfscsvt_b_tag_up, ncsvt_tags);
if (syst == "BTagDown") return b_csvt_1_tag.weight(jsfscsvt_b_tag_down, ncsvt_tags);
if (syst == "MisTagUp") return b_csvt_1_tag.weight(jsfscsvt_mis_tag_up, ncsvt_tags);
if (syst == "MisTagDown") return b_csvt_1_tag.weight(jsfscsvt_mis_tag_down, ncsvt_tags);
return b_csvt_1_tag.weight(jsfscsvt, ncsvt_tags);
}
if (B == 2 || B == 5)
{
if (syst == "BTagUp") return b_csvt_2_tags.weight(jsfscsvt_b_tag_up, ncsvt_tags);
if (syst == "BTagDown") return b_csvt_2_tags.weight(jsfscsvt_b_tag_down, ncsvt_tags);
if (syst == "MisTagUp") return b_csvt_2_tags.weight(jsfscsvt_mis_tag_up, ncsvt_tags);
if (syst == "MisTagDown") return b_csvt_2_tags.weight(jsfscsvt_mis_tag_down, ncsvt_tags);
return b_csvt_2_tags.weight(jsfscsvt, ncsvt_tags);
}
return 1.;
}
double SingleTopSystematicsTreesDumper::pileUpSF(string syst)
{
if (syst == "PUUp" )return LumiWeightsUp_.weight( *n0);
if (syst == "PUDown" )return LumiWeightsDown_.weight( *n0);
return LumiWeights_.weight( *n0);
}
double SingleTopSystematicsTreesDumper::resolSF(double eta, string syst)
{
double fac = 0.;
if (syst == "JERUp")fac = 1.;
if (syst == "JERDown")fac = -1.;
if (eta <= 0.5) return 0.052 + 0.063 * fac;
else if ( eta > 0.5 && eta <= 1.1 ) return 0.057 + 0.057 * fac;
else if ( eta > 1.1 && eta <= 1.7 ) return 0.096 + 0.065 * fac;
else if ( eta > 1.7 && eta <= 2.3 ) return 0.134 + 0.093 * fac;
else if ( eta > 2.3 && eta <= 5. ) return 0.288 + 0.200 * fac;
return 0.1;
}
//BTag weighter
bool SingleTopSystematicsTreesDumper::BTagWeight::filter(int t)
{
return (t >= minTags && t <= maxTags);
}
float SingleTopSystematicsTreesDumper::BTagWeight::weight(vector<JetInfo> jets, int tags)
{
if (!filter(tags))
{
// std::cout << "nThis event should not pass the selection, what is it doing here?" << std::endl;
return 0;
}
int njets = jets.size();
int comb = 1 << njets;
float pMC = 0;
float pData = 0;
for (int i = 0; i < comb; i++)
{
float mc = 1.;
float data = 1.;
int ntagged = 0;
for (int j = 0; j < njets; j++)
{
bool tagged = ((i >> j) & 0x1) == 1;
if (tagged)
{
ntagged++;
mc *= jets[j].eff;
data *= jets[j].eff * jets[j].sf;
}
else
{
mc *= (1. - jets[j].eff);
data *= (1. - jets[j].eff * jets[j].sf);
}
}
if (filter(ntagged))
{
// std::cout << mc << " " << data << endl;
pMC += mc;
pData += data;
}
}
if (pMC == 0) return 0;
return pData / pMC;
}
float SingleTopSystematicsTreesDumper::BTagWeight::weightWithVeto(vector<JetInfo> jetsTags, int tags, vector<JetInfo> jetsVetoes, int vetoes)
{//This function takes into account cases where you have n b-tags and m vetoes, but they have different thresholds.
if (!filter(tags))
{
// std::cout << "nThis event should not pass the selection, what is it doing here?" << std::endl;
return 0;
}
int njets = jetsTags.size();
if(njets != (int)(jetsVetoes.size()))return 0;//jets tags and vetoes must have same size!
int comb = 1 << njets;
float pMC = 0;
float pData = 0;
for (int i = 0; i < comb; i++)
{
float mc = 1.;
float data = 1.;
int ntagged = 0;
for (int j = 0; j < njets; j++)
{
bool tagged = ((i >> j) & 0x1) == 1;
if (tagged)
{
ntagged++;
mc *= jetsTags[j].eff;
data *= jetsTags[j].eff * jetsTags[j].sf;
}
else
{
mc *= (1. - jetsVetoes[j].eff);
data *= (1. - jetsVetoes[j].eff * jetsVetoes[j].sf);
}
}
if (filter(ntagged))
{
// std::cout << mc << " " << data << endl;
pMC += mc;
pData += data;
}
}
if (pMC == 0) return 0;
return pData / pMC;
}
void SingleTopSystematicsTreesDumper::muonHLTSF(float etaMu, float ptMu){
double pt = ptMu;
double eta = etaMu;
sfID=1;sfIDup=1;sfIDdown=1;
sfIso=1;sfIsoup=1;sfIsodown=1;
sfTrig=1;sfTrigup=1;sfTrigdown=1;
//ID Iso SF for ABCD
if(fabs(eta)<=0.9) { if (pt > 10 && pt < 20){sfID = 0.984868; sfIDup = 0.990827; sfIDdown = 0.978922 ; }
if (pt > 20 && pt < 25){sfID = 0.988681; sfIDup = 0.990443; sfIDdown = 0.986914 ; }
if (pt > 25 && pt < 30){sfID = 0.993889; sfIDup = 0.994673; sfIDdown = 0.9931 ; }
if (pt > 30 && pt < 35){sfID = 0.994164; sfIDup = 0.994709; sfIDdown = 0.993617 ; }
if (pt > 35 && pt < 40){sfID = 0.994084; sfIDup = 0.994505; sfIDdown = 0.993662 ; }
if (pt > 40 && pt < 50){sfID = 0.99247; sfIDup = 0.992741; sfIDdown = 0.992199 ; }
if (pt > 50 && pt < 60){sfID = 0.990978; sfIDup = 0.991644; sfIDdown = 0.990308 ; }
if (pt > 60 && pt < 90){sfID = 0.990444; sfIDup = 0.991505; sfIDdown = 0.989377 ; }
if (pt > 90 && pt < 140){sfID = 1.00385; sfIDup = 1.00714; sfIDdown = 1.00055 ; }
if (pt > 140 && pt < 300){sfID = 1.02798; sfIDup = 1.04694; sfIDdown = 1.00922 ; }
if (pt > 300 && pt < 500){sfID = 1; sfIDup = 1; sfIDdown = 0.67606 ; }
if (pt > 10 && pt < 20){sfIso = 0.94705; sfIsoup = 0.949803; sfIsodown = 0.944293 ; }
if (pt > 20 && pt < 25){sfIso = 0.974978; sfIsoup = 0.976512; sfIsodown = 0.97344 ; }
if (pt > 25 && pt < 30){sfIso = 0.997129; sfIsoup = 0.998065; sfIsodown = 0.99619 ; }
if (pt > 30 && pt < 35){sfIso = 0.993863; sfIsoup = 0.994484; sfIsodown = 0.993242 ; }
if (pt > 35 && pt < 40){sfIso = 0.993442; sfIsoup = 0.993872; sfIsodown = 0.993009 ; }
if (pt > 40 && pt < 50){sfIso = 0.994101; sfIsoup = 0.994322; sfIsodown = 0.993878 ; }
if (pt > 50 && pt < 60){sfIso = 0.995544; sfIsoup = 0.995948; sfIsodown = 0.995137 ; }
if (pt > 60 && pt < 90){sfIso = 0.999036; sfIsoup = 0.999501; sfIsodown = 0.998565 ; }
if (pt > 90 && pt < 140){sfIso = 1.00104; sfIsoup = 1.00192; sfIsodown = 1.00013 ; }
if (pt > 140 && pt < 300){sfIso = 1.0003; sfIsoup = 1.00201; sfIsodown = 0.998474 ; }
if (pt > 300 && pt < 500){sfIso = 1.01977; sfIsoup = 1.02914; sfIsodown = 1.00747 ; }
}
if(fabs(eta)<=1.2&& fabs(eta)>0.9) { if (pt > 10 && pt < 20){sfID = 0.986855; sfIDup = 0.993819; sfIDdown = 0.979939 ; }
if (pt > 20 && pt < 25){sfID = 0.987375; sfIDup = 0.989974; sfIDdown = 0.984765 ; }
if (pt > 25 && pt < 30){sfID = 0.994212; sfIDup = 0.995638; sfIDdown = 0.992776 ; }
if (pt > 30 && pt < 35){sfID = 0.990593; sfIDup = 0.991663; sfIDdown = 0.989516 ; }
if (pt > 35 && pt < 40){sfID = 0.990353; sfIDup = 0.991142; sfIDdown = 0.989559 ; }
if (pt > 40 && pt < 50){sfID = 0.989641; sfIDup = 0.990134; sfIDdown = 0.989147 ; }
if (pt > 50 && pt < 60){sfID = 0.991311; sfIDup = 0.992578; sfIDdown = 0.990035 ; }
if (pt > 60 && pt < 90){sfID = 0.98631; sfIDup = 0.988322; sfIDdown = 0.98428 ; }
if (pt > 90 && pt < 140){sfID = 1.01191; sfIDup = 1.01838; sfIDdown = 1.00536 ; }
if (pt > 140 && pt < 300){sfID = 0.955563; sfIDup = 0.990509; sfIDdown = 0.921661 ; }
if (pt > 300 && pt < 500){sfID = 1; sfIDup = 1; sfIDdown = 0.489937 ; }
if (pt > 10 && pt < 20){sfIso = 0.951836; sfIsoup = 0.954998; sfIsodown = 0.948665 ; }
if (pt > 20 && pt < 25){sfIso = 0.988368; sfIsoup = 0.99068; sfIsodown = 0.986047 ; }
if (pt > 25 && pt < 30){sfIso = 1.00083; sfIsoup = 1.00248; sfIsodown = 0.999185 ; }
if (pt > 30 && pt < 35){sfIso = 0.998546; sfIsoup = 0.999708; sfIsodown = 0.997378 ; }
if (pt > 35 && pt < 40){sfIso = 0.99914; sfIsoup = 0.999886; sfIsodown = 0.998392 ; }
if (pt > 40 && pt < 50){sfIso = 0.998176; sfIsoup = 0.998528; sfIsodown = 0.997824 ; }
if (pt > 50 && pt < 60){sfIso = 0.998696; sfIsoup = 0.999342; sfIsodown = 0.99804 ; }
if (pt > 60 && pt < 90){sfIso = 0.999132; sfIsoup = 0.999902; sfIsodown = 0.998346 ; }
if (pt > 90 && pt < 140){sfIso = 0.999559; sfIsoup = 1.00095; sfIsodown = 0.998088 ; }
if (pt > 140 && pt < 300){sfIso = 0.996767; sfIsoup = 0.999567; sfIsodown = 0.993535 ; }
if (pt > 300 && pt < 500){sfIso = 1.00784; sfIsoup = 1.02465; sfIsodown = 0.981759 ; }
}
if(fabs(eta)<2.1&& fabs(eta)>1.2) { if (pt > 10 && pt < 20){sfID = 1.01235; sfIDup = 1.01633; sfIDdown = 1.00839 ; }
if (pt > 20 && pt < 25){sfID = 1.00155; sfIDup = 1.00304; sfIDdown = 1.00006 ; }
if (pt > 25 && pt < 30){sfID = 0.999149; sfIDup = 1.00003; sfIDdown = 0.998262 ; }
if (pt > 30 && pt < 35){sfID = 0.997573; sfIDup = 0.998294; sfIDdown = 0.99685 ; }
if (pt > 35 && pt < 40){sfID = 0.996585; sfIDup = 0.997183; sfIDdown = 0.995984 ; }
if (pt > 40 && pt < 50){sfID = 0.997431; sfIDup = 0.997804; sfIDdown = 0.997056 ; }
if (pt > 50 && pt < 60){sfID = 0.997521; sfIDup = 0.998468; sfIDdown = 0.996571 ; }
if (pt > 60 && pt < 90){sfID = 0.993942; sfIDup = 0.995548; sfIDdown = 0.992327 ; }
if (pt > 90 && pt < 140){sfID = 1.01922; sfIDup = 1.02491; sfIDdown = 1.0135 ; }
if (pt > 140 && pt < 300){sfID = 1.01648; sfIDup = 1.04966; sfIDdown = 0.982238 ; }
if (pt > 300 && pt < 500){sfID = 0.608799; sfIDup = 1; sfIDdown = 0.169285 ; }
if (pt > 10 && pt < 20){sfIso = 0.980045; sfIsoup = 0.981666; sfIsodown = 0.978421 ; }
if (pt > 20 && pt < 25){sfIso = 0.997342; sfIsoup = 0.998548; sfIsodown = 0.996133 ; }
if (pt > 25 && pt < 30){sfIso = 1.00784; sfIsoup = 1.00871; sfIsodown = 1.00696 ; }
if (pt > 30 && pt < 35){sfIso = 1.00685; sfIsoup = 1.00752; sfIsodown = 1.00618 ; }
if (pt > 35 && pt < 40){sfIso = 1.0037; sfIsoup = 1.00416; sfIsodown = 1.00323 ; }
if (pt > 40 && pt < 50){sfIso = 1.00209; sfIsoup = 1.0023; sfIsodown = 1.00188 ; }
if (pt > 50 && pt < 60){sfIso = 1.00125; sfIsoup = 1.00163; sfIsodown = 1.00086 ; }
if (pt > 60 && pt < 90){sfIso = 1.00065; sfIsoup = 1.00112; sfIsodown = 1.00018 ; }
if (pt > 90 && pt < 140){sfIso = 0.999878; sfIsoup = 1.00081; sfIsodown = 0.998902 ; }
if (pt > 140 && pt < 300){sfIso = 0.99989; sfIsoup = 1.00205; sfIsodown = 0.997507 ; }
if (pt > 300 && pt < 500){sfIso = 1.01392; sfIsoup = 1.02575; sfIsodown = 0.995749 ; }
}
//ABCD
//Trigger Run D
if(fabs(eta)<=0.9) { if (pt > 25 && pt < 30){sfTrig = 0.979145; sfTrigup = 0.980946; sfTrigdown = 0.977338 ; }
if (pt > 30 && pt < 35){sfTrig = 0.980195; sfTrigup = 0.981314; sfTrigdown = 0.979072 ; }
if (pt > 35 && pt < 40){sfTrig = 0.981218; sfTrigup = 0.981981; sfTrigdown = 0.980454 ; }
if (pt > 40 && pt < 50){sfTrig = 0.982317; sfTrigup = 1.06112; sfTrigdown = 0.981954 ; }
if (pt > 50 && pt < 60){sfTrig = 0.981793; sfTrigup = 0.982783; sfTrigdown = 0.980797 ; }
if (pt > 60 && pt < 90){sfTrig = 0.985262; sfTrigup = 0.98673; sfTrigdown = 0.983781 ; }
if (pt > 90 && pt < 140){sfTrig = 0.985298; sfTrigup = 0.990194; sfTrigdown = 0.980271 ; }
if (pt > 140 && pt < 500){sfTrig = 0.986012; sfTrigup = 0.999074; sfTrigdown = 0.971938 ; }
}
if(fabs(eta)<=1.2&& fabs(eta)>0.9) { if (pt > 25 && pt < 30){sfTrig = 0.962613; sfTrigup = 0.966528; sfTrigdown = 0.958684 ; }
if (pt > 30 && pt < 35){sfTrig = 0.959007; sfTrigup = 0.961889; sfTrigdown = 0.956115 ; }
if (pt > 35 && pt < 40){sfTrig = 0.9618; sfTrigup = 0.963988; sfTrigdown = 0.959605 ; }
if (pt > 40 && pt < 50){sfTrig = 0.962938; sfTrigup = 0.964187; sfTrigdown = 0.961686 ; }
if (pt > 50 && pt < 60){sfTrig = 0.960298; sfTrigup = 0.96326; sfTrigdown = 0.95732 ; }
if (pt > 60 && pt < 90){sfTrig = 0.956722; sfTrigup = 0.961223; sfTrigdown = 0.952188 ; }
if (pt > 90 && pt < 140){sfTrig = 0.962339; sfTrigup = 0.976841; sfTrigdown = 0.947468 ; }
if (pt > 140 && pt < 500){sfTrig = 0.99289; sfTrigup = 1.02694; sfTrigdown = 0.955269 ; }
}
if(fabs(eta)<2.1&& fabs(eta)>1.2) { if (pt > 25 && pt < 30){sfTrig = 1.00472; sfTrigup = 1.00727; sfTrigdown = 1.00218 ; }
if (pt > 30 && pt < 35){sfTrig = 1.00194; sfTrigup = 1.00392; sfTrigdown = 0.999953 ; }
if (pt > 35 && pt < 40){sfTrig = 0.998212; sfTrigup = 0.999835; sfTrigdown = 0.996586 ; }
if (pt > 40 && pt < 50){sfTrig = 0.996583; sfTrigup = 0.997588; sfTrigdown = 0.995575 ; }
if (pt > 50 && pt < 60){sfTrig = 0.991098; sfTrigup = 0.993481; sfTrigdown = 0.988707 ; }
if (pt > 60 && pt < 90){sfTrig = 0.983799; sfTrigup = 0.987389; sfTrigdown = 0.980192 ; }
if (pt > 90 && pt < 140){sfTrig = 0.983428; sfTrigup = 0.995422; sfTrigdown = 0.971255 ; }
if (pt > 140 && pt < 500){sfTrig = 0.944096; sfTrigup = 0.983253; sfTrigdown = 0.903315 ; }
}
lepSFD=sfTrig*sfIso*sfID;
lepSFIDUpD=sfTrig*sfIso*sfIDup;
lepSFIDDownD=sfTrig*sfIso*sfIDdown;
lepSFIsoUpD=sfTrig*sfID*sfIsoup;
lepSFIsoDownD=sfTrig*sfID*sfIsodown;
lepSFTrigUpD=sfID*sfIso*sfTrigup;
lepSFTrigDownD=sfID*sfIso*sfTrigdown;
//Trigger Run C
if(fabs(eta)<=0.9) { if (pt > 25 && pt < 30){sfTrig = 0.986052; sfTrigup = 0.987446; sfTrigdown = 0.98465 ; }
if (pt > 30 && pt < 35){sfTrig = 0.985515; sfTrigup = 0.98642; sfTrigdown = 0.984605 ; }
if (pt > 35 && pt < 40){sfTrig = 0.984947; sfTrigup = 0.985592; sfTrigdown = 0.984298 ; }
if (pt > 40 && pt < 50){sfTrig = 0.983213; sfTrigup = 0.983753; sfTrigdown = 0.982674 ; }
if (pt > 50 && pt < 60){sfTrig = 0.983801; sfTrigup = 0.984719; sfTrigdown = 0.982878 ; }
if (pt > 60 && pt < 90){sfTrig = 0.983397; sfTrigup = 0.984783; sfTrigdown = 0.982 ; }
if (pt > 90 && pt < 140){sfTrig = 0.977086; sfTrigup = 0.981907; sfTrigdown = 0.972136 ; }
if (pt > 140 && pt < 500){sfTrig = 0.983315; sfTrigup = 0.995474; sfTrigdown = 0.970149 ; }
}
if(fabs(eta)<=1.2&& fabs(eta)>0.9) { if (pt > 25 && pt < 30){sfTrig = 0.9761; sfTrigup = 0.979632; sfTrigdown = 0.97255 ; }
if (pt > 30 && pt < 35){sfTrig = 0.969575; sfTrigup = 0.972217; sfTrigdown = 0.966921 ; }
if (pt > 35 && pt < 40){sfTrig = 0.971727; sfTrigup = 0.973774; sfTrigdown = 0.969673 ; }
if (pt > 40 && pt < 50){sfTrig = 0.968551; sfTrigup = 0.969478; sfTrigdown = 0.967617 ; }
if (pt > 50 && pt < 60){sfTrig = 0.966893; sfTrigup = 0.969728; sfTrigdown = 0.964041 ; }
if (pt > 60 && pt < 90){sfTrig = 0.959999; sfTrigup = 0.964271; sfTrigdown = 0.955696 ; }
if (pt > 90 && pt < 140){sfTrig = 0.959322; sfTrigup = 0.973596; sfTrigdown = 0.944637 ; }
if (pt > 140 && pt < 500){sfTrig = 1.0146; sfTrigup = 1.05261; sfTrigdown = 0.97273 ; }
}
lepSFC=sfTrig*sfIso*sfID;
lepSFIDUpC=sfTrig*sfIso*sfIDup;
lepSFIDDownC=sfTrig*sfIso*sfIDdown;
lepSFIsoUpC=sfTrig*sfID*sfIsoup;
lepSFIsoDownC=sfTrig*sfID*sfIsodown;
lepSFTrigUpC=sfID*sfIso*sfTrigup;
lepSFTrigDownC=sfID*sfIso*sfTrigdown;
//Trigger Run B
if(fabs(eta)<=0.9) { if (pt > 25 && pt < 30){sfTrig = 0.978858; sfTrigup = 0.980843; sfTrigdown = 0.976865 ; }
if (pt > 30 && pt < 35){sfTrig = 0.979803; sfTrigup = 0.981049; sfTrigdown = 0.978553 ; }
if (pt > 35 && pt < 40){sfTrig = 0.979755; sfTrigup = 0.980612; sfTrigdown = 0.978895 ; }
if (pt > 40 && pt < 50){sfTrig = 0.979681; sfTrigup = 0.980176; sfTrigdown = 0.979433 ; }
if (pt > 50 && pt < 60){sfTrig = 0.978707; sfTrigup = 0.979846; sfTrigdown = 0.97756 ; }
if (pt > 60 && pt < 90){sfTrig = 0.981103; sfTrigup = 0.982791; sfTrigdown = 0.9794 ; }
if (pt > 90 && pt < 140){sfTrig = 0.98042; sfTrigup = 0.986075; sfTrigdown = 0.9746 ; }
if (pt > 140 && pt < 500){sfTrig = 0.974405; sfTrigup = 0.988661; sfTrigdown = 0.959129 ; }
}
if(fabs(eta)<=1.2&& fabs(eta)>0.9) { if (pt > 25 && pt < 30){sfTrig = 0.97007; sfTrigup = 0.974442; sfTrigdown = 0.965677 ; }
if (pt > 30 && pt < 35){sfTrig = 0.962694; sfTrigup = 0.965879; sfTrigdown = 0.959495 ; }
if (pt > 35 && pt < 40){sfTrig = 0.960235; sfTrigup = 0.962675; sfTrigdown = 0.957787 ; }
if (pt > 40 && pt < 50){sfTrig = 0.962149; sfTrigup = 0.963544; sfTrigdown = 0.960747 ; }
if (pt > 50 && pt < 60){sfTrig = 0.959086; sfTrigup = 0.962429; sfTrigdown = 0.955723 ; }
if (pt > 60 && pt < 90){sfTrig = 0.952173; sfTrigup = 0.957241; sfTrigdown = 0.94706 ; }
if (pt > 90 && pt < 140){sfTrig = 0.949186; sfTrigup = 0.965981; sfTrigdown = 0.931917 ; }
if (pt > 140 && pt < 500){sfTrig = 0.953607; sfTrigup = 0.999454; sfTrigdown = 0.903591 ; }
}
if(fabs(eta)<2.1&& fabs(eta)>1.2) { if (pt > 25 && pt < 30){sfTrig = 0.995013; sfTrigup = 0.997841; sfTrigdown = 0.992179 ; }
if (pt > 30 && pt < 35){sfTrig = 0.986493; sfTrigup = 0.988727; sfTrigdown = 0.984256 ; }
if (pt > 35 && pt < 40){sfTrig = 0.9815; sfTrigup = 0.983319; sfTrigdown = 0.979677 ; }
if (pt > 40 && pt < 50){sfTrig = 0.978702; sfTrigup = 0.979837; sfTrigdown = 0.977566 ; }
if (pt > 50 && pt < 60){sfTrig = 0.97745; sfTrigup = 0.980154; sfTrigdown = 0.974737 ; }
if (pt > 60 && pt < 90){sfTrig = 0.975728; sfTrigup = 0.979825; sfTrigdown = 0.971608 ; }
if (pt > 90 && pt < 140){sfTrig = 0.955204; sfTrigup = 0.968591; sfTrigdown = 0.941583 ; }
if (pt > 140 && pt < 500){sfTrig = 0.982866; sfTrigup = 1.02659; sfTrigdown = 0.936749 ; }
}
lepSFB=sfTrig*sfIso*sfID;
lepSFIDUpB=sfTrig*sfIso*sfIDup;
lepSFIDDownB=sfTrig*sfIso*sfIDdown;
lepSFIsoUpB=sfTrig*sfID*sfIsoup;
lepSFIsoDownB=sfTrig*sfID*sfIsodown;
lepSFTrigUpB=sfID*sfIso*sfTrigup;
lepSFTrigDownB=sfID*sfIso*sfTrigdown;
//Trigger Run A
if(fabs(eta)<=0.9) { if (pt > 25 && pt < 30){sfTrig = 0.938137; sfTrigup = 0.94254; sfTrigdown = 0.933702 ; }
if (pt > 30 && pt < 35){sfTrig = 0.942347; sfTrigup = 0.945148; sfTrigdown = 0.939526 ; }
if (pt > 35 && pt < 40){sfTrig = 0.951167; sfTrigup = 0.953089; sfTrigdown = 0.949232 ; }
if (pt > 40 && pt < 50){sfTrig = 0.960094; sfTrigup = 0.961208; sfTrigdown = 0.958976 ; }
if (pt > 50 && pt < 60){sfTrig = 0.97344; sfTrigup = 0.975881; sfTrigdown = 0.970964 ; }
if (pt > 60 && pt < 90){sfTrig = 0.975737; sfTrigup = 0.979319; sfTrigdown = 0.972082 ; }
if (pt > 90 && pt < 140){sfTrig = 0.980291; sfTrigup = 0.992657; sfTrigdown = 0.96703 ; }
if (pt > 140 && pt < 500){sfTrig = 1.00399; sfTrigup = 1.02648; sfTrigdown = 0.97399 ; }
}
if(fabs(eta)<=1.2&& fabs(eta)>0.9) { if (pt > 25 && pt < 30){sfTrig = 0.940447; sfTrigup = 0.949624; sfTrigdown = 0.931184 ; }
if (pt > 30 && pt < 35){sfTrig = 0.941756; sfTrigup = 0.948636; sfTrigdown = 0.93482 ; }
if (pt > 35 && pt < 40){sfTrig = 0.961844; sfTrigup = 0.96685; sfTrigdown = 0.956797 ; }
if (pt > 40 && pt < 50){sfTrig = 0.958809; sfTrigup = 0.961669; sfTrigdown = 0.955932 ; }
if (pt > 50 && pt < 60){sfTrig = 0.943967; sfTrigup = 0.950932; sfTrigdown = 0.936907 ; }
if (pt > 60 && pt < 90){sfTrig = 0.944023; sfTrigup = 0.954631; sfTrigdown = 0.933205 ; }
if (pt > 90 && pt < 140){sfTrig = 0.985552; sfTrigup = 1.01463; sfTrigdown = 0.954264 ; }
if (pt > 140 && pt < 500){sfTrig = 0.879259; sfTrigup = 0.975855; sfTrigdown = 0.763416 ; }
}
if(fabs(eta)<2.1&& fabs(eta)>1.2) { if (pt > 25 && pt < 30){sfTrig = 0.980088; sfTrigup = 0.985963; sfTrigdown = 0.974184 ; }
if (pt > 30 && pt < 35){sfTrig = 0.989347; sfTrigup = 0.993926; sfTrigdown = 0.984746 ; }
if (pt > 35 && pt < 40){sfTrig = 0.98464; sfTrigup = 0.988287; sfTrigdown = 0.980976 ; }
if (pt > 40 && pt < 50){sfTrig = 0.979771; sfTrigup = 0.982028; sfTrigdown = 0.977509 ; }
if (pt > 50 && pt < 60){sfTrig = 0.982233; sfTrigup = 0.987606; sfTrigdown = 0.976813 ; }
if (pt > 60 && pt < 90){sfTrig = 0.965242; sfTrigup = 0.973585; sfTrigdown = 0.956801 ; }
if (pt > 90 && pt < 140){sfTrig = 0.977609; sfTrigup = 1.00735; sfTrigdown = 0.946395 ; }
if (pt > 140 && pt < 500){sfTrig = 1.02767; sfTrigup = 1.08628; sfTrigdown = 0.956645 ; }
}
lepSF=sfTrig*sfIso*sfID;
lepSFIDUp=sfTrig*sfIso*sfIDup;
lepSFIDDown=sfTrig*sfIso*sfIDdown;
lepSFIsoUp=sfTrig*sfID*sfIsoup;
lepSFIsoDown=sfTrig*sfID*sfIsodown;
lepSFTrigUp=sfID*sfIso*sfTrigup;
lepSFTrigDown=sfID*sfIso*sfTrigdown;
////
}
void SingleTopSystematicsTreesDumper::electronHLTSF(float etaEle, float ptEle){
double pt = ptEle;
double eta = etaEle;
sfID=1;sfIDup=1;sfIDdown=1;
sfIso=1;sfIsoup=1;sfIsodown=1;
sfTrig=1;sfTrigup=1;sfTrigdown=1;
cout << " cutbased "<< useCutBasedID_<< " mnva "<< useMVAID_<<endl;
if(useMVAID_>0){
if(fabs(eta)<0.8){
if(pt>30 && pt <40 ){sfID=0.939;
sfIDdown=sfID-0.003;sfIDup=sfID+0.003;
}
if(pt>40 && pt <50 ){sfID=0.950;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.001;
}
if(pt>50 ){sfID=0.957;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
}
if(fabs(eta)>0.8&&fabs(eta)<1.478){
if(pt>30 && pt <40 ){sfID=0.920;
sfIDdown=sfID-0.001;sfIDup=sfID+0.002;
}
if(pt>40 && pt <50 ){sfID=0.949;
sfIDdown=sfID-0.002;sfIDup=sfID+0.002;
}
if(pt>50 ){sfID=0.959;
sfIDdown=sfID-0.003;sfIDup=sfID+0.003;
}
}
if(fabs(eta)>1.478){
if(pt>30 && pt <40 ){sfID=0.907;
sfIDdown=sfID-0.005;sfIDup=sfID+0.005;
}
if(pt>40 && pt <50 ){sfID=0.937;
sfIDdown=sfID-0.008;sfIDup=sfID+0.008;
}
if(pt>50 ){sfID=0.954;
sfIDdown=sfID-0.010;sfIDup=sfID+0.011;
}
}
}
cout << "tccc"<<endl;
if(useCutBasedID_>0) {
cout << " using cutbased, eta "<<eta << " pt "<<pt<<" sfID "<< sfID <<endl;
if(fabs(eta)<0.8){
if(pt>30 && pt <40 ){
sfID=0.976;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
if(pt>40 && pt <50 ){
sfID=0.983;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
if(pt>50){
sfID=0.980;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
}
if(fabs(eta)>0.8&&fabs(eta)<1.442){
if(pt>30 && pt <40 ){
sfID=0.967;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
if(pt>40 && pt <50 ){
sfID=0.981;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
if(pt>50){
sfID=0.980;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
}
if(fabs(eta)>1.442&&fabs(eta)<1.556){
if(pt>30 && pt <40 ){
sfID=0.966;
sfIDdown=sfID-0.008;sfIDup=sfID+0.008;
}
if(pt>40 && pt <50 ){
sfID=0.951;
sfIDdown=sfID-0.006;sfIDup=sfID+0.006;
}
if(pt>50){
sfID=0.942;
sfIDdown=sfID-0.017;sfIDup=sfID+0.017;
}
}
if(fabs(eta)>1.556&&fabs(eta)<2.0){
if(pt>30 && pt <40 ){
sfID=0.961;
sfIDdown=sfID-0.001;sfIDup=sfID+0.003;
}
if(pt>40 && pt <50 ){
sfID=0.982;
sfIDdown=sfID-0.002;sfIDup=sfID+0.002;
}
if(pt>50){
sfID=0.986;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
}
if(fabs(eta)>2.0&&fabs(eta)<2.5){
if(pt>30 && pt <40 ){
sfID=1.006;
sfIDdown=sfID-0.001;sfIDup=sfID+0.003;
}
if(pt>40 && pt <50 ){
sfID=1.012;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
}
if(pt>50){
sfID=1.016;
sfIDdown=sfID-0.002;sfIDup=sfID+0.002;
}
}
}
cout << " after cutbased, eta "<<eta << " pt "<<pt<<" sfID after "<< sfID <<endl;
if(fabs(eta)<0.8){
if(pt>30 && pt <40 ){sfTrig=0.987;
sfTrigdown=sfTrig-0.003;sfTrigup=sfTrig+0.003;
}
if(pt>40 && pt <50 ){sfTrig=0.997;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.001;
}
if(pt>50 ){sfTrig=0.998;
sfTrigdown=sfTrig-0.002;sfTrigup=sfTrig+0.002;
}
}
if(fabs(eta)>0.8&&fabs(eta)<1.478){
if(pt>30 && pt <40 ){sfTrig=0.964;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.002;
}
if(pt>40 && pt <50 ){sfTrig=0.980;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.001;
}
if(pt>50 ){sfTrig=0.988;
sfTrigdown=sfTrig-0.002;sfTrigup=sfTrig+0.002;
}
}
if(fabs(eta)>1.478){
if(pt>30 && pt <40 ){sfTrig=1.004;
sfTrigdown=sfTrig-0.006;sfTrigup=sfTrig+0.006;
}
if(pt>40 && pt <50 ){sfTrig=1.033;
sfTrigdown=sfTrig-0.007;sfTrigup=sfTrig+0.007;
}
if(pt>50 ){sfTrig=0.976;
sfTrigdown=sfTrig-0.012;sfTrigup=sfTrig+0.015;
}
}
lepSF=sfTrig*sfIso*sfID;
lepSFIDUp=sfTrig*sfIso*sfIDup;
lepSFIDDown=sfTrig*sfIso*sfIDdown;
lepSFIsoUp=sfTrig*sfID*sfIsoup;
lepSFIsoDown=sfTrig*sfID*sfIsodown;
lepSFTrigUp=sfID*sfIso*sfTrigup;
lepSFTrigDown=sfID*sfIso*sfTrigdown;
}
//define this as a plug-in
DEFINE_FWK_MODULE(SingleTopSystematicsTreesDumper);
/*
if(fabs(eta)<0.8){
if(pt>30 && pt <40 ){sfID=0.939;sfTrig=0.987;
sfIDdown=sfID-0.003;sfIDup=sfID+0.003;
sfTrigdown=sfTrig-0.003;sfTrigup=sfTrig+0.003;
}
if(pt>40 && pt <50 ){sfID=0.950;sfTrig=0.997;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.001;
}
if(pt>50 ){sfID=0.957;sfTrig=0.998;
sfIDdown=sfID-0.001;sfIDup=sfID+0.001;
sfTrigdown=sfTrig-0.002;sfTrigup=sfTrig+0.002;
}
}
if(fabs(eta)>0.8&&fabs(eta)<1.478){
if(pt>30 && pt <40 ){sfID=0.920;sfTrig=0.964;
sfIDdown=sfID-0.001;sfIDup=sfID+0.002;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.002;
}
if(pt>40 && pt <50 ){sfID=0.949;sfTrig=0.980;
sfIDdown=sfID-0.002;sfIDup=sfID+0.002;
sfTrigdown=sfTrig-0.001;sfTrigup=sfTrig+0.001;
}
if(pt>50 ){sfID=0.959;sfTrig=0.988;
sfIDdown=sfID-0.003;sfIDup=sfID+0.003;
sfTrigdown=sfTrig-0.002;sfTrigup=sfTrig+0.002;
}
}
if(fabs(eta)>1.478){
if(pt>30 && pt <40 ){sfID=0.907;sfTrig=1.004;
sfIDdown=sfID-0.005;sfIDup=sfID+0.005;
sfTrigdown=sfTrig-0.006;sfTrigup=sfTrig+0.006;
}
if(pt>40 && pt <50 ){sfID=0.937;sfTrig=1.033;
sfIDdown=sfID-0.008;sfIDup=sfID+0.008;
sfTrigdown=sfTrig-0.007;sfTrigup=sfTrig+0.007;
}
if(pt>50 ){sfID=0.954;sfTrig=0.976;
sfIDdown=sfID-0.010;sfIDup=sfID+0.011;
sfTrigdown=sfTrig-0.012;sfTrigup=sfTrig+0.015;
}
}
*/
| [
"decosa@t3ui05.psi.ch"
] | decosa@t3ui05.psi.ch |
bc378999fa24f7e84f47165df13fcc48f8ddcf38 | 85aed0bcac5d6aea781dff64029c2d23fcba984b | /EngineUILib/GUInterface/UIWindowBody.cpp | 7eb24cb9a2adcbd0c4228597b7a7253094176f79 | [] | no_license | youdontknowme17/ura | 3c76bf05eccd38b454b389841f1db49b59217e46 | e31bc9fd9c2312175d250dc4dc1f9c656c7f2004 | refs/heads/master | 2020-03-28T15:49:00.379682 | 2018-09-15T09:57:49 | 2018-09-15T09:57:49 | 148,628,762 | 0 | 2 | null | null | null | null | UHC | C++ | false | false | 1,444 | cpp | #include "StdAfx.h"
#include "UIWindowBody.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
CUIWindowBody::CUIWindowBody ()
{
}
CUIWindowBody::~CUIWindowBody ()
{
}
void CUIWindowBody::CreateBody ( char* szLeft, char* szUp, char* szMain, char* szDown, char* szRight )
{
//UIRECT rcOriginPos = GetGlobalPos ();
//WORD wAlignFlag = UI_FLAG_DEFAULT;
//WORD wAlignFlag;
CUIControl* pLeft = new CUIControl;
//wAlignFlag = UI_FLAG_YSIZE;
pLeft->CreateSub ( this, szLeft, UI_FLAG_YSIZE );
//pLeft->SetControlNameEx( "왼쪽라인" );
RegisterControl ( pLeft );
CUIControl* pUp = new CUIControl;
//wAlignFlag = UI_FLAG_XSIZE;
pUp->CreateSub ( this, szUp, UI_FLAG_XSIZE );
//pUp->SetControlNameEx( "위쪽라인" );
RegisterControl ( pUp );
CUIControl* pMain = new CUIControl;
//wAlignFlag = UI_FLAG_XSIZE | UI_FLAG_YSIZE;
pMain->CreateSub ( this, szMain, UI_FLAG_XSIZE | UI_FLAG_YSIZE );
//pMain->SetControlNameEx( "메인" );
RegisterControl ( pMain );
CUIControl* pDown = new CUIControl;
//wAlignFlag = UI_FLAG_BOTTOM | UI_FLAG_XSIZE;
pDown->CreateSub ( this, szDown, UI_FLAG_BOTTOM | UI_FLAG_XSIZE );
//pDown->SetControlNameEx( "아래라인" );
RegisterControl ( pDown );
CUIControl* pRight = new CUIControl;
//wAlignFlag = UI_FLAG_RIGHT | UI_FLAG_YSIZE;
pRight->CreateSub ( this, szRight, UI_FLAG_RIGHT | UI_FLAG_YSIZE );
//pRight->SetControlNameEx( "오른쪽라인" );
RegisterControl ( pRight );
} | [
"markcalimosa@gmail.com"
] | markcalimosa@gmail.com |
b96115f34bc3d2fe9b0f23475c5b5060b90989bd | 3fc1ee94ebece7022c99d69cad39c3710487a74a | /chromeos/services/multidevice_setup/public/cpp/prefs.cc | 3bba3821d1f85f2c0878109230871be0aa34f4c0 | [
"BSD-3-Clause"
] | permissive | vseal001/chromium | b78653699caa6d54f45401ad0d9e3e90c160b8fb | 474eca05898d2524072c2e3d962a866ddcfe37fc | refs/heads/master | 2023-01-15T05:05:41.728378 | 2018-08-07T12:38:42 | 2018-08-07T12:38:42 | 143,872,860 | 0 | 1 | null | 2018-08-07T12:52:25 | 2018-08-07T12:52:25 | null | UTF-8 | C++ | false | false | 2,033 | 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 "chromeos/services/multidevice_setup/public/cpp/prefs.h"
#include "components/prefs/pref_registry_simple.h"
namespace chromeos {
namespace multidevice_setup {
// Note that the pref names have slightly inconsistent naming conventions
// because some were named before the unified MultiDeviceSetup project and we
// wanted to avoid changing the internal names of existing prefs. The general
// naming pattern for each individual feature enabling pref moving forward
// should be of the form
// const char k[FeatureName]FeatureEnabledPrefName =
// "multidevice_setup.[feature_name]_enabled";
// This pref is a gatekeeper for all MultiDevice features (e.g. Easy Unlock,
// Instant Tethering). Setting the pref to 'true' is necessary but not
// sufficient to enable the individual features, which are each controlled by
// their own pref and may involve additional setup steps.
const char kSuiteEnabledPrefName[] = "multidevice_setup.suite_enabled";
// Individual feature prefs.
const char kAndroidMessagesFeatureEnabledPrefName[] =
"multidevice.sms_connect_enabled";
// Whether Instant Tethering is allowed by policy.
const char kInstantTetheringFeatureAllowedPrefName[] = "tether.allowed";
// Whether Instant Tethering is enabled by the user. Note that if the feature is
// enabled by the user but disallowed by policy, it is unavailable.
const char kInstantTetheringFeatureEnabledPrefName[] = "tether.enabled";
void RegisterFeaturePrefs(PrefRegistrySimple* registry) {
registry->RegisterBooleanPref(kSuiteEnabledPrefName, false);
registry->RegisterBooleanPref(kAndroidMessagesFeatureEnabledPrefName, false);
registry->RegisterBooleanPref(kInstantTetheringFeatureAllowedPrefName, true);
registry->RegisterBooleanPref(kInstantTetheringFeatureEnabledPrefName, true);
}
} // namespace multidevice_setup
} // namespace chromeos
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
33208d727c9d25e945644a8880ded312e7322319 | 078927a49a6c5f7e3de1a99cc9b13aad233c0a7d | /Eudora_W_source/Sandbox/Eudora/WazooBar.h | e5247b4f1dff5e9be5e74b6b28826ca8e92dce97 | [] | no_license | avar/rhqben | ac74c3893bf965eaf8911579f68fe7557f907dcc | 966db0f6a3c7d78cc9ddcab1709f9ac38fdcdd5b | refs/heads/master | 2020-03-18T07:45:21.766714 | 2018-05-22T20:15:44 | 2018-05-22T20:16:47 | 134,471,376 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,471 | h | #ifndef __WAZOOBAR_H__
#define __WAZOOBAR_H__
// WazooBar.h : header file
//
// CWazooBar
// Specific implementation of a resizable SECControlBar.
#include "QC3DTabWnd.h"
///////////////////////////////////////////////////////////////////////
// CWazooBarOleDropTarget
//
// Private class that overrides CView-based implementation of
// COleDropTarget to work with CWazooBar objects.
///////////////////////////////////////////////////////////////////////
class CWazooBarOleDropTarget : public COleDropTarget
{
friend class CWazooBar; // private class
private:
CWazooBarOleDropTarget()
{
}
virtual ~CWazooBarOleDropTarget()
{
}
public:
// Overridables
virtual DROPEFFECT OnDragEnter(CWnd* pWnd, COleDataObject* pDataObject,
DWORD dwKeyState, CPoint point);
virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject,
DWORD dwKeyState, CPoint point);
virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject,
DROPEFFECT dropEffect, CPoint point);
virtual void OnDragLeave(CWnd* pWnd);
virtual DROPEFFECT OnDropEx(CWnd* pWnd, COleDataObject* pDataObject,
DROPEFFECT dropDefault, DROPEFFECT dropList,
CPoint point);
// virtual DROPEFFECT OnDragScroll(CWnd* pWnd, DWORD dwKeyState, CPoint point);
private:
CWazooBarOleDropTarget(const CWazooBarOleDropTarget&); // not implemented
void operator=(const CWazooBarOleDropTarget&); // not implemented
};
/////////////////////////////////////////////////////////////////////////////
// CWazooBar control bar
class CWazooWnd;
class CWazooBarMgr;
///////////////////////////////////////////////////////////////////////
// CWazooBar
//
///////////////////////////////////////////////////////////////////////
class CWazooBar : public SECControlBar
{
friend class CWazooBarOleDropTarget; // mi casa es su casa
friend class CWazooBarMgr;
DECLARE_DYNCREATE(CWazooBar)
// Construction
protected:
CWazooBar() {} // not used!
public:
CWazooBar(CWazooBarMgr* pManager);
virtual ~CWazooBar();
// Bit mask flags for 'nFlags' value saved to INI file
enum
{
FLAGS_VISIBLE = 0x1, // Is visible MDI child window
FLAGS_ACTIVE = 0x2 // Is active MDI child window
};
// Attributes
public:
// Operations
public:
BOOL AddWazooWindow(CWazooWnd* pWazooWnd, const CPoint& ptScreen);
BOOL RemoveWazooWindow(CWazooWnd* pWazooWnd);
BOOL ShuffleWazooWindow(CWazooWnd* pWazooWnd, const CPoint& ptScreen);
BOOL ActivateWazooWindow(CRuntimeClass* pRuntimeClass);
CWazooWnd* GetActiveWazooWindow();
void SetActiveWazooWindow();
BOOL ContainsWazooWindow(CRuntimeClass* pRuntimeClass);
BOOL UnlinkFromManager();
int GetWazooCount();
CWnd* QCTabHitTest(const CPoint& ptScreen, BOOL& bSelected, int& nIndex);
virtual BOOL SetDefaultWazooConfig(int nBar);
virtual BOOL LoadWazooConfigFromIni();
virtual BOOL SaveWazooConfigToIni();
void RefreshWindowTitle();
virtual BOOL PreTranslateMessage(MSG* pMsg);
// Overrides
public:
virtual void OnBarFloat();
virtual void OnBarMDIFloat();
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CWazooBar)
protected:
//}}AFX_VIRTUAL
// Implementation
public:
// Generated message map functions
protected:
// required implementation of a pure virtual
virtual void OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);
// override base class implementation
virtual void OnExtendContextMenu(CMenu* pMenu);
BOOL CreateWazooWindow(CRuntimeClass* pRuntimeClass);
QC3DTabWnd m_wndTab;
CWazooBarMgr* m_pManager;
enum
{
AUTOACTIVATE_TIMER_EVENT_ID = 1001
};
//{{AFX_MSG(CWazooBar)
afx_msg void OnOK();
afx_msg void OnCancel();
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnDestroy();
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
afx_msg void OnCmdSECMDIFloat();
afx_msg void OnTabsOnTop();
afx_msg void OnTabsOnBottom();
afx_msg void OnTabsOnLeft();
afx_msg void OnTabsOnRight();
afx_msg void OnTabsShowSingleTab();
afx_msg LRESULT OnTabSelect(WPARAM wParam, LPARAM lParam);
afx_msg void OnTimer(UINT nIDEvent);
afx_msg void OnWindowPosChanging(WINDOWPOS* lpwndpos);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
private:
BOOL GetNextParam(CString& strParams, CString& strParam) const;
//
// Registered object for OLE Drag and Drop callbacks.
//
CWazooBarOleDropTarget m_dropTarget;
UINT m_idAutoActivateTimer; // for tab drag and drop auto-activation
};
#endif //__WAZOOBAR_H__
| [
"avarab@gmail.com"
] | avarab@gmail.com |
beb05301386052a29a89a23c98034f287bada3ee | e2950433484e55ae76cbc03c946aba6886eaf4d6 | /src/token.cpp | 3492af56715aea6f1193381ba754dba56fdfbec9 | [
"Apache-2.0"
] | permissive | eruffaldi/cmm | 29a7a17c3ab7cab5dd1225ab97e0af010c94234f | ba2942a89231d85141b8d226331e0940492ec661 | refs/heads/master | 2021-01-10T11:50:15.862897 | 2016-01-11T18:33:59 | 2016-01-11T18:33:59 | 49,097,212 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,512 | cpp | // Nome: token
// Progetto: CPP/Lexer
// Autore: Ruffaldi Emanuele
// Descrizione: implementazione dei contenitori di token
#include "token.h"
#include <string.h>
static char * nomi[] = {
"tknNONE",
"tknIDENT",
"", "", "" , "", "",
"EOF",
"<=", ">=", "==", "<<", ">>", "++", "--",
"->", "...", "&&", "||",
};
static char * altri[] = {
"break", "if", "else", "while", "const", "do", "for",
"continue", "int", "float", "void", "char", "sizeof","return"
};
ostream& operator<< (ostream& o, const Token& r)
{
switch(r.type) {
case tknCCONST:
if(r.getCConst() == '\n')
o << "\'n\'";
else
o << "0x" << hex << int(r.getCConst());
break;
case tknIDENT: o << r.getSymbol(); break;
case tknICONST: o << r.getIConst(); break;
case tknSTRCONST: o << '\"' << r.getString() << '\"'; break;
case tknFCONST: o << r.getFConst(); break;
default:
if(r.type >= tknSECONDI && r.type < tknUltimo)
o << altri[r.type-tknBREAK];
else if(r.type <= tknULTIMO1)
o << nomi[r.type];
else
o << char(r.type);
}
return o;
}
Token::Token()
{
type = tknNONE;
}
Token::~Token()
{
cleanSymbol();
}
Token::Token(const Token&r)
{
type = tknNONE;
switch(r.type) {
case tknIDENT:
setSymbol(r.getSymbol());
break;
case tknICONST:
setIConst(r.getIConst());
break;
case tknSTRCONST:
// qui richiede duplicazione
{
char * cp = new char[r.getStringLength()];
memcpy(cp, r.getString(), r.getStringLength());
setString(cp, r.getStringLength());
}
case tknFCONST:
setFConst(r.getFConst());
break;
case tknCCONST:
setCConst(r.getCConst());
break;
default:
type = r.type;
break;
}
}
inline void Token::cleanSymbol()
{
if(type == tknIDENT)
delete [] symbol;
else if(type == tknSTRCONST)
delete[] stringa.str;
}
void Token::setSymbol(const char * s)
{
cleanSymbol();
symbol = new char[strlen(s)+1];
strcpy(symbol, s);
type = tknIDENT;
}
void Token::setString(char * s, int n)
{
cleanSymbol();
stringa.str = s;
stringa.len = n;
type = tknSTRCONST;
}
void Token::setIConst(int i)
{
cleanSymbol();
type = tknICONST;
iconst = i;
}
void Token::setTokenType(int t)
{
cleanSymbol();
type = TokenType(t);
}
void Token::setCConst(char c)
{
cleanSymbol();
type = tknCCONST;
cconst = c;
}
void Token::setFConst(float f)
{
cleanSymbol();
type = tknFCONST;
fconst = f;
}
| [
"emanuele.ruffaldi@gmail.com"
] | emanuele.ruffaldi@gmail.com |
4ca33046defdc64b71003911db29c15cb9792dc5 | 37cca16f12e7b1d4d01d6f234da6d568c318abee | /ext/stub/java/lang/Math_RandomNumberGeneratorHolder-stub.cpp | a63b66ce850320bef3f9931db0f8b1056b8875d8 | [] | no_license | subhash1-0/thirstyCrow | e48155ce68fc886f2ee8e7802567c1149bc54206 | 78b7e4e3d2b9a9530ad7d66b44eacfe73ceea582 | refs/heads/master | 2016-09-06T21:25:54.075724 | 2015-09-21T17:21:15 | 2015-09-21T17:21:15 | 42,881,521 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,013 | cpp | // Generated from C:/Program Files/Java/jre1.8.0_51/lib/rt.jar
#include <java/lang/Math_RandomNumberGeneratorHolder.hpp>
extern void unimplemented_(const char16_t* name);
java::lang::Math_RandomNumberGeneratorHolder::Math_RandomNumberGeneratorHolder(const ::default_init_tag&)
: super(*static_cast< ::default_init_tag* >(0))
{
clinit();
}
java::util::Random*& java::lang::Math_RandomNumberGeneratorHolder::randomNumberGenerator()
{
clinit();
return randomNumberGenerator_;
}
java::util::Random* java::lang::Math_RandomNumberGeneratorHolder::randomNumberGenerator_;
/* private: void ::java::lang::Math_RandomNumberGeneratorHolder::ctor() */
extern java::lang::Class *class_(const char16_t *c, int n);
java::lang::Class* java::lang::Math_RandomNumberGeneratorHolder::class_()
{
static ::java::lang::Class* c = ::class_(u"java.lang.Math.RandomNumberGeneratorHolder", 42);
return c;
}
java::lang::Class* java::lang::Math_RandomNumberGeneratorHolder::getClass0()
{
return class_();
}
| [
"sgurjar@adobe.com"
] | sgurjar@adobe.com |
595b6be0ae23eea5658c527d9b245f5e3bf9b69c | cccfb7be281ca89f8682c144eac0d5d5559b2deb | /third_party/blink/renderer/modules/csspaint/nativepaint/clip_path_paint_image_generator_impl.cc | f62b6cbd32b04763ed6d344d5b2a4b021c547aa7 | [
"Apache-2.0",
"LGPL-2.0-or-later",
"MIT",
"GPL-1.0-or-later",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause"
] | permissive | SREERAGI18/chromium | 172b23d07568a4e3873983bf49b37adc92453dd0 | fd8a8914ca0183f0add65ae55f04e287543c7d4a | refs/heads/master | 2023-08-27T17:45:48.928019 | 2021-11-11T22:24:28 | 2021-11-11T22:24:28 | 428,659,250 | 1 | 0 | BSD-3-Clause | 2021-11-16T13:08:14 | 2021-11-16T13:08:14 | null | UTF-8 | C++ | false | false | 1,746 | cc | // Copyright 2021 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 "third_party/blink/renderer/modules/csspaint/nativepaint/clip_path_paint_image_generator_impl.h"
#include "third_party/blink/renderer/modules/csspaint/nativepaint/clip_path_paint_definition.h"
#include "third_party/blink/renderer/platform/graphics/image.h"
namespace blink {
ClipPathPaintImageGenerator* ClipPathPaintImageGeneratorImpl::Create(
LocalFrame& local_root) {
ClipPathPaintDefinition* clip_path_paint_definition =
ClipPathPaintDefinition::Create(local_root);
DCHECK(clip_path_paint_definition);
ClipPathPaintImageGeneratorImpl* generator =
MakeGarbageCollected<ClipPathPaintImageGeneratorImpl>(
clip_path_paint_definition);
return generator;
}
ClipPathPaintImageGeneratorImpl::ClipPathPaintImageGeneratorImpl(
ClipPathPaintDefinition* clip_path_paint_definition)
: clip_path_paint_definition_(clip_path_paint_definition) {}
scoped_refptr<Image> ClipPathPaintImageGeneratorImpl::Paint(
float zoom,
const FloatRect& reference_box,
const Node& node) {
return clip_path_paint_definition_->Paint(zoom, reference_box, node);
}
Animation* ClipPathPaintImageGeneratorImpl::GetAnimationIfCompositable(
const Element* element) {
return ClipPathPaintDefinition::GetAnimationIfCompositable(element);
}
void ClipPathPaintImageGeneratorImpl::Shutdown() {
clip_path_paint_definition_->UnregisterProxyClient();
}
void ClipPathPaintImageGeneratorImpl::Trace(Visitor* visitor) const {
visitor->Trace(clip_path_paint_definition_);
ClipPathPaintImageGenerator::Trace(visitor);
}
} // namespace blink
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
0985b6e3409abbb9bde2fa763cecfa676244c8e6 | ce6f4f5f4cb9d07fb410409c27bd6057e8655c93 | /homework_1/Q72/Main.cpp | 7e4f816f47c4d010da086686d64631820012da19 | [] | no_license | Kunduin/CPP_homework | 8b7aab167a036c81ca39b89a98d394893b74828d | 464e6540e0b536c7c6353bab587411c0416f5a68 | refs/heads/master | 2021-07-19T17:40:38.082222 | 2017-10-06T06:57:57 | 2017-10-06T06:57:57 | 105,973,729 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 787 | cpp | #include<iostream>
#include<string>
#include<vector>
using namespace std;
int main()
{
string roman;
cin >> roman;
vector<int> num;
long long sum = 0;
for (long long i = 0; i < roman.length(); i++)
{
switch (roman[i])
{
case'I':
num.push_back(1);
break;
case'X':
num.push_back(10);
break;
case'C':
num.push_back(100);
break;
case'M':
num.push_back(1000);
break;
case'V':
num.push_back(5);
break;
case'L':
num.push_back(50);
break;
case'D':
num.push_back(500);
break;
default:
break;
}
}
for (long long i = 0; i < roman.length(); i++)
{
if ((num[i] == 1 || num[i] == 10 || num[i] == 100) && (i != num.size() - 1)&&num[i]<num[i+1])
{
sum -= num[i];
}
else
{
sum += num[i];
}
}
cout << sum;
} | [
"15852158126@163.com"
] | 15852158126@163.com |
1693d8d4685ce6292ab5f3071959ae591c9547c7 | b20633cef14a620eb8825291506f060b062ee77f | /src/libs/actions/detail/values.h | 642e08c12d2b490e84530ebd14ca6a9f33138f5e | [
"MIT"
] | permissive | adam-urbanczyk/possumwood | aa0b46c2341e6f0864a1a12c78311b5396b4ae6e | ba6e941f21f3adaee0734a436a8034bbf96b6a9c | refs/heads/master | 2020-12-23T08:04:12.926107 | 2020-01-26T13:31:51 | 2020-01-26T13:31:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 657 | h | #pragma once
#include <boost/optional.hpp>
#include <dependency_graph/network.h>
#include <actions/io/json.h>
#include "../undo_stack.h"
#include "../node_data.h"
namespace possumwood { namespace actions { namespace detail {
possumwood::UndoStack::Action setValueAction(dependency_graph::Port& port, const dependency_graph::BaseData& value);
possumwood::UndoStack::Action setValueAction(const dependency_graph::UniqueId& nodeId, std::size_t portId, const dependency_graph::BaseData& value);
possumwood::UndoStack::Action setValueAction(const dependency_graph::UniqueId& nodeId, const std::string& portName, const possumwood::io::json& value);
} } }
| [
"martin.prazak@gmail.com"
] | martin.prazak@gmail.com |
7b99fa3d84bfd4ff89e865aa3496a25264d87f41 | 668ac416ccbd85d1513f40a07a30918975634e98 | /CENTRAL 3D/Source/ModuleEventManager.cpp | ec6b158f98b775b4921856f71dea09448fba239b | [
"MIT"
] | permissive | AitorSimona/CENTRAL-3D | ec0b7761c8f09b0070f86748b1f697818ca702fd | 01700230b4733e6976fb14971dcc835374f8db12 | refs/heads/master | 2021-09-28T02:20:08.660510 | 2021-09-22T14:29:54 | 2021-09-22T14:29:54 | 209,045,472 | 5 | 4 | MIT | 2020-04-20T13:55:42 | 2019-09-17T12:17:17 | C++ | UTF-8 | C++ | false | false | 1,990 | cpp | #include "ModuleEventManager.h"
#include "mmgr/mmgr.h"
ModuleEventManager::ModuleEventManager(bool start_enabled)
{
static_assert(static_cast<int>(Event::EventType::invalid) == EVENT_TYPES-1, "EVENT_TYPES macro needs to be updated!");
head = 0;
tail = 0;
}
ModuleEventManager::~ModuleEventManager()
{
}
bool ModuleEventManager::Init(json file)
{
return true;
}
bool ModuleEventManager::Start()
{
return true;
}
update_status ModuleEventManager::PreUpdate(float dt)
{
while (head != tail)
{
// Process events
int EventType = static_cast<int>(events[head].type);
for (std::vector<Function>::iterator it = listeners[EventType].listeners.begin(); it != listeners[EventType].listeners.end(); ++it)
{
// MYTODO: check if we can call the function first, delete listener if it is inaccessible
(*it)(events[head]);
}
head = (head + 1) % MAX_EVENTS;
}
return update_status::UPDATE_CONTINUE;
}
bool ModuleEventManager::CleanUp()
{
for (uint i = 0; i < EVENT_TYPES; ++i)
{
listeners[i].listeners.clear();
}
return true;
}
void ModuleEventManager::PushEvent(Event& new_event)
{
// --- Add given event to the end of the list ---
events[tail] = new_event;
tail = (tail + 1) % MAX_EVENTS;
}
void ModuleEventManager::AddListener(Event::EventType type, Function callback)
{
int EventType = static_cast<int>(type);
bool found = false;
for (std::vector<Function>::iterator it = listeners[EventType].listeners.begin(); it != listeners[EventType].listeners.end(); ++it)
{
if (*it == callback)
{
found = true;
break;
}
}
if(!found)
listeners[EventType].listeners.push_back(callback);
}
void ModuleEventManager::RemoveListener(Event::EventType type, Function callback)
{
int EventType = static_cast<int>(type);
for(std::vector<Function>::iterator it = listeners[EventType].listeners.begin(); it != listeners[EventType].listeners.end(); ++it)
{
if (*it == callback)
{
listeners[EventType].listeners.erase(it);
break;
}
}
}
| [
"simonaaitor@gmail.com"
] | simonaaitor@gmail.com |
0327bdeb7f53345dbe8fc03a21661fc1750ddda4 | 6b40e9dccf2edc767c44df3acd9b626fcd586b4d | /NT/shell/shell32/unicpp/dcomp.h | 12e287ccbe021fa596a8814f1432d0418ec1cf23 | [] | no_license | jjzhang166/WinNT5_src_20201004 | 712894fcf94fb82c49e5cd09d719da00740e0436 | b2db264153b80fbb91ef5fc9f57b387e223dbfc2 | refs/heads/Win2K3 | 2023-08-12T01:31:59.670176 | 2021-10-14T15:14:37 | 2021-10-14T15:14:37 | 586,134,273 | 1 | 0 | null | 2023-01-07T03:47:45 | 2023-01-07T03:47:44 | null | UTF-8 | C++ | false | false | 7,872 | h | #ifndef _DCOMP_H_
#define _DCOMP_H_
#include <cowsite.h>
EXTERN_C IActiveDesktop * g_pActiveDeskAdv;
//
// Whether a particular desktop icon is shown or not depends on whether start panel is on or off.
// So, the individual preferences are persisted in two different registry locations given below!
#define REGSTR_PATH_HIDDEN_DESKTOP_ICONS REGSTR_PATH_EXPLORER TEXT("\\HideDesktopIcons\\%s")
#define REGSTR_VALUE_STARTPANEL TEXT("NewStartPanel")
#define REGSTR_VALUE_CLASSICMENU TEXT("ClassicStartMenu")
#define REGSTR_PATH_HIDDEN_MYCOMP_ICONS REGSTR_PATH_EXPLORER TEXT("\\HideMyComputerIcons")
#define REGSTR_PATH_EXP_SHELLFOLDER REGSTR_PATH_EXPLORER TEXT("\\CLSID\\%s\\ShellFolder")
#define REGVAL_ATTRIBUTES TEXT("Attributes")
// The following array has the two registry sub-locations where the desktop icon on/off data
// is stored based on whether start panel is off/on.
const LPTSTR c_apstrRegLocation[] =
{
REGSTR_VALUE_CLASSICMENU, // Use this if classic menu is on.
REGSTR_VALUE_STARTPANEL // Use this if start panel is on.
};
// Name of the file that holds each icon, and an index for which icon to use in the file
typedef struct tagIconKeys
{
TCHAR szOldFile[MAX_PATH];
int iOldIndex;
TCHAR szNewFile[MAX_PATH];
int iNewIndex;
}ICONDATA;
extern GUID CLSID_EffectsPage;
// Registry Info for the icons
typedef struct tagIconRegKeys
{
const CLSID* pclsid;
TCHAR szIconValue[16];
int iTitleResource;
int iDefaultTitleResource;
LPCWSTR pszDefault;
int nDefaultIndex;
}ICONREGKEYS;
static const ICONREGKEYS c_aIconRegKeys[] =
{
{ &CLSID_MyComputer, TEXT("\0"), 0, IDS_MYCOMPUTER, L"%WinDir%\\explorer.exe", 0},
{ &CLSID_MyDocuments, TEXT("\0"), 0, IDS_MYDOCUMENTS2, L"%WinDir%\\system32\\mydocs.dll", 0},
{ &CLSID_NetworkPlaces, TEXT("\0"), 0, IDS_NETNEIGHBOUR, L"%WinDir%\\system32\\shell32.dll", 17},
{ &CLSID_RecycleBin, TEXT("full"), IDS_FULL, IDS_TRASHFULL, L"%WinDir%\\system32\\shell32.dll", 32},
{ &CLSID_RecycleBin, TEXT("empty"), IDS_EMPTY2, IDS_TRASHEMPTY, L"%WinDir%\\system32\\shell32.dll", 31},
};
#define NUM_ICONS (ARRAYSIZE(c_aIconRegKeys))
enum ICON_SIZE_TYPES {
ICON_DEFAULT = 0,
ICON_LARGE = 1,
ICON_INDETERMINATE = 2
};
#define ICON_DEFAULT_SMALL 16
#define ICON_DEFAULT_NORMAL 32
#define ICON_DEFAULT_LARGE 48
typedef struct tagDeskIconId {
int iDeskIconDlgItemId;
LPCWSTR pwszCLSID;
const CLSID *pclsid;
BOOL fCheckNonEnumAttrib;
BOOL fCheckNonEnumPolicy;
} DESKICONID;
// Array if desktop icons we would like to turn-on/off individually
static const DESKICONID c_aDeskIconId[] =
{
{IDC_DESKTOP_ICON_MYDOCS, L"{450D8FBA-AD25-11D0-98A8-0800361B1103}", &CLSID_MyDocuments, TRUE , TRUE }, // My Documents
{IDC_DESKTOP_ICON_MYCOMP, L"{20D04FE0-3AEA-1069-A2D8-08002B30309D}", &CLSID_MyComputer, FALSE , TRUE }, // My Computer
{IDC_DESKTOP_ICON_MYNET, L"{208D2C60-3AEA-1069-A2D7-08002B30309D}", &CLSID_NetworkPlaces, TRUE , TRUE }, // Network Places
{IDC_DESKTOP_ICON_IE, L"{871C5380-42A0-1069-A2EA-08002B30309D}", &CLSID_Internet, TRUE , TRUE } // Internet Explorer
};
// The sub-string that preceeds the CLSID when passed as the property name.
// For example, when "SP_1{645FF040-5081-101B-9F08-00AA002F954E}" is passed as the property name,
// it refers to the recycle icon when StartPage is ON.
//
static const LPWSTR c_awszSP[] =
{
L"SP_0", //Indicates StartPage Off.
L"SP_1", //Indicates StartPage On.
L"POLI" //Indicates that we want the policy info!
};
static const LPWSTR c_wszPropNameFormat = L"%s%s";
#define STARTPAGE_ON_PREFIX c_awszSP[1] //The prefix string for StartPage_On.
#define STARTPAGE_OFF_PREFIX c_awszSP[0] //The prefix string for StartPage_Off.
#define LEN_PROP_PREFIX lstrlenW(c_awszSP[0]) //Length of the prefix string.
#define POLICY_PREFIX c_awszSP[2]
#define NUM_DESKICONS (ARRAYSIZE(c_aDeskIconId))
#ifndef EXCLUDE_COMPPROPSHEET
class CCompPropSheetPage : public CObjectWithSite
, public IAdvancedDialog
{
public:
//////////////////////////////////////////////////////
// Public Interfaces
//////////////////////////////////////////////////////
// *** IUnknown ***
virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
virtual STDMETHODIMP_(ULONG) AddRef(void);
virtual STDMETHODIMP_(ULONG) Release(void);
// *** IAdvancedDialog ***
virtual STDMETHODIMP DisplayAdvancedDialog(IN HWND hwndParent, IN IPropertyBag * pAdvPage, IN BOOL * pfEnableApply);
CCompPropSheetPage(void);
protected:
int _cRef;
ICONDATA _IconData[NUM_ICONS];
HWND _hwndLV;
BOOL _fAllowAdd;
BOOL _fAllowDel;
BOOL _fAllowEdit;
BOOL _fAllowClose;
BOOL _fAllowReset;
BOOL _fLockDesktopItems;
BOOL _fForceAD;
BOOL _fLaunchGallery; // Did we launch the gallery at any time?
BOOL _fInitialized; // Did we finished adding the items to the list view?
HWND _hWndList; // handle to the list view window
HIMAGELIST _hIconList; // handles to image lists for large icons
BOOL _fCustomizeDesktopOK; // was OK clicked when the customize desktop property sheet dialog was closed?
int _iStartPanelOn;
BOOL _afHideIcon[2][NUM_DESKICONS];
BOOL _afDisableCheckBox[NUM_DESKICONS];
int _iPreviousSelection;
int m_nIndex;
void _AddComponentToLV(COMPONENTA *pcomp);
void _SetUIFromDeskState(BOOL fEmpty);
void _OnInitDialog(HWND hwnd, INT iPage);
void _OnNotify(HWND hwnd, WPARAM wParam, LPNMHDR lpnm);
void _OnCommand(HWND hwnd, WORD wNotifyCode, WORD wID, HWND hwndCtl);
void _OnDestroy(INT iPage);
void _OnGetCurSel(int *piIndex);
void _EnableControls(HWND hwnd);
BOOL _VerifyFolderOptions(void);
void _SelectComponent(LPWSTR pwszUrl);
HRESULT _OnInitDesktopOptionsUI(HWND hwnd);
HRESULT _LoadIconState(IN IPropertyBag * pAdvPage);
HWND _CreateListView(HWND hWndParent);
void _NewComponent(HWND hwnd);
void _EditComponent(HWND hwnd);
void _DeleteComponent(HWND hwnd);
void _SynchronizeAllComponents(IActiveDesktop *pActDesktop);
void _TryIt(void);
void _DesktopCleaner(HWND hwnd);
HRESULT _IsDirty(IN BOOL * pIsDirty);
HRESULT _MergeIconState(IN IPropertyBag * pAdvPage);
HRESULT _LoadDeskIconState(IN IPropertyBag * pAdvPage);
HRESULT _MergeDeskIconState(IN IPropertyBag * pAdvPage);
HRESULT _UpdateDesktopIconsUI(HWND hwnd);
private:
virtual ~CCompPropSheetPage(void);
// Private Member Functions
INT_PTR _CustomizeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam, INT iPage);
static INT_PTR _CustomizeDlgProcHelper(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam, INT iPage);
static INT_PTR CALLBACK CustomizeDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam);
static INT_PTR CALLBACK WebDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam);
};
BOOL FindComponent(IN LPCTSTR pszUrl, IN IActiveDesktop * pActiveDesktop);
void CreateComponent(COMPONENTA *pcomp, LPCTSTR pszUrl);
INT_PTR NewComponent(HWND hwndOwner, IActiveDesktop * pad, BOOL fDeferGallery, COMPONENT * pcomp);
BOOL LooksLikeFile(LPCTSTR psz);
BOOL IsUrlPicture(LPCTSTR pszUrl);
#endif // EXCLUDE_COMPPROPSHEET
#define WM_COMP_GETCURSEL (WM_USER+1)
#endif
| [
"seta7D5@protonmail.com"
] | seta7D5@protonmail.com |
f21dbac85fb42696ccc4b4cfcc3620e619fd256f | ea312c782edb62e7d8d506a307f5074311a1c492 | /MyImage/Source/PluginProcessor.h | 32f472d683ecfd6d70d673064c3f9b1c3857bb6b | [
"MIT"
] | permissive | niuniu502/Juce_Audio_Tutorial | 5950635b81666f9cdfc4890ca445570ecb5b6e19 | e9cdb3fc68c54c24d05b8f38b8384e947f269949 | refs/heads/master | 2022-10-27T16:45:50.801349 | 2020-06-18T16:12:23 | 2020-06-18T16:12:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,280 | h | /*
==============================================================================
This file was auto-generated!
It contains the basic framework code for a JUCE plugin processor.
==============================================================================
*/
#pragma once
#include <JuceHeader.h>
//==============================================================================
/**
*/
class MyImageAudioProcessor : public AudioProcessor
{
public:
//==============================================================================
MyImageAudioProcessor();
~MyImageAudioProcessor();
//==============================================================================
void prepareToPlay (double sampleRate, int samplesPerBlock) override;
void releaseResources() override;
#ifndef JucePlugin_PreferredChannelConfigurations
bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
#endif
void processBlock (AudioBuffer<float>&, MidiBuffer&) override;
//==============================================================================
AudioProcessorEditor* createEditor() override;
bool hasEditor() const override;
//==============================================================================
const String getName() const override;
bool acceptsMidi() const override;
bool producesMidi() const override;
bool isMidiEffect() const override;
double getTailLengthSeconds() const override;
//==============================================================================
int getNumPrograms() override;
int getCurrentProgram() override;
void setCurrentProgram (int index) override;
const String getProgramName (int index) override;
void changeProgramName (int index, const String& newName) override;
//==============================================================================
void getStateInformation (MemoryBlock& destData) override;
void setStateInformation (const void* data, int sizeInBytes) override;
private:
//==============================================================================
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MyImageAudioProcessor)
};
| [
"noreply@github.com"
] | noreply@github.com |
17456bb2e6d378bd9beedbd066e0ff843d51469b | 322eccdb14d9402a9795e7687b87d4aad2e5b19f | /libwgn/libwgn/Tool/WGEdit.h | 54c5389a059d7c0119d96c914ca7b5d71fee6ab0 | [] | no_license | wangguozhu/libwgn | 0564fc19c75b8b9cbf3aa94184d28774105affa7 | bc5a8f75b501ce3bf4b6cac20dc28887f3da174b | refs/heads/master | 2023-02-07T17:30:20.230430 | 2023-02-04T01:31:22 | 2023-02-04T01:31:22 | 101,642,951 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,129 | h | #pragma once
/// @class CAjEdit
/// @brief 自定义编辑框
class CAjEdit : public CEdit
{
DECLARE_DYNAMIC(CAjEdit)
public:
CAjEdit();
virtual ~CAjEdit();
public:
/// @brief 设置可视区域
/// @param [in ] rc 可视区域
void SetShowRect(const CRect& rc);
/// @brief 更新父DC
void UpDateDC(void);
protected:
DECLARE_MESSAGE_MAP()
/// @brief 背景画刷
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
/// @brief 鼠标左键
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
/// @brief 鼠标移动
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
/// @brief 画刷
afx_msg HBRUSH CtlColor(CDC* /*pDC*/, UINT /*nCtlColor*/);
afx_msg UINT OnGetDlgCode();
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
afx_msg void OnEnChange();
afx_msg void OnPaint();
private:
/// @brief 计算位置
void CalcPos(void);
/// @brief 释放
void Release(void);
private:
CDC m_dcParent; // 父资源的DC
CBitmap m_dcBmp; // 资源图片
CBitmap* m_pOldBmp; // 父资源的旧的图片
CRect m_ShowRect; // 可视区域
CPoint m_LBtnPt; // 左键按钮
}; | [
"475259729@qq.com"
] | 475259729@qq.com |
19f7f6d783d0db19ea639ca0c95844af886fd84e | 3296cab14de3ba88ba01637c634f213f2345da55 | /HIDF/HFRepIDF/external/libIgl/include/igl/read_triangle_mesh.cpp | f9b0ebf4c05c68a6e979d76e8a54a058eb113feb | [] | no_license | teshaTe/HybridFrep | 63b2fe47a6ce49927309743e1f708658c2f2f18d | ded2bbb917bd1f8bc22e28b35bdf86cf6b0340a7 | refs/heads/master | 2023-03-04T01:35:36.054376 | 2021-02-18T21:36:13 | 2021-02-18T21:36:13 | 158,251,562 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,348 | cpp | // This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2013 Alec Jacobson <alecjacobson@gmail.com>
//
// 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 "read_triangle_mesh.h"
#include "list_to_matrix.h"
#include "readMSH.h"
#include "readMESH.h"
#include "readOBJ.h"
#include "readOFF.h"
#include "readSTL.h"
#include "readPLY.h"
#include "readWRL.h"
#include "pathinfo.h"
#include "boundary_facets.h"
#include "polygon_mesh_to_triangle_mesh.h"
#include <algorithm>
#include <iostream>
template <typename Scalar, typename Index>
IGL_INLINE bool igl::read_triangle_mesh(
const std::string str,
std::vector<std::vector<Scalar> > & V,
std::vector<std::vector<Index> > & F)
{
using namespace std;
// dirname, basename, extension and filename
string d,b,e,f;
pathinfo(str,d,b,e,f);
// Convert extension to lower case
std::transform(e.begin(), e.end(), e.begin(), ::tolower);
vector<vector<Scalar> > TC, N, C;
vector<vector<Index> > FTC, FN;
if(e == "obj")
{
// Annoyingly obj can store 4 coordinates, truncate to xyz for this generic
// read_triangle_mesh
bool success = readOBJ(str,V,TC,N,F,FTC,FN);
for(auto & v : V)
{
v.resize(std::min(v.size(),(size_t)3));
}
return success;
}else if(e == "off")
{
return readOFF(str,V,F,N,C);
}
cerr<<"Error: "<<__FUNCTION__<<": "<<
str<<" is not a recognized mesh file format."<<endl;
return false;
}
#ifndef IGL_NO_EIGN
template <typename DerivedV, typename DerivedF>
IGL_INLINE bool igl::read_triangle_mesh(
const std::string str,
Eigen::PlainObjectBase<DerivedV>& V,
Eigen::PlainObjectBase<DerivedF>& F)
{
std::string _1,_2,_3,_4;
return read_triangle_mesh(str,V,F,_1,_2,_3,_4);
}
template <typename DerivedV, typename DerivedF>
IGL_INLINE bool igl::read_triangle_mesh(
const std::string filename,
Eigen::PlainObjectBase<DerivedV>& V,
Eigen::PlainObjectBase<DerivedF>& F,
std::string & dir,
std::string & base,
std::string & ext,
std::string & name)
{
using namespace std;
using namespace Eigen;
// dirname, basename, extension and filename
pathinfo(filename,dir,base,ext,name);
// Convert extension to lower case
transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
// readMSH requires filename
if(ext == "msh")
{
// readMSH is not properly templated
Eigen::MatrixXd mV;
Eigen::MatrixXi mF,T;
Eigen::VectorXi _1,_2;
// *TetWild doesn't use Tri field...
//bool res = readMSH(filename,mV,mF);
bool res = readMSH(filename,mV,mF,T,_1,_2);
V = mV.template cast<typename DerivedV::Scalar>();
if(mF.rows() == 0 && T.rows() > 0)
{
boundary_facets(T,F);
// outward facing
F = F.rowwise().reverse().eval();
}else
{
F = mF.template cast<typename DerivedF::Scalar>();
}
return res;
}else
{
FILE * fp = fopen(filename.c_str(),"rb");
if(NULL==fp)
{
fprintf(stderr,"IOError: %s could not be opened...\n",
filename.c_str());
return false;
}
return read_triangle_mesh(ext,fp,V,F);
}
}
template <typename DerivedV, typename DerivedF>
IGL_INLINE bool igl::read_triangle_mesh(
const std::string & ext,
FILE * fp,
Eigen::PlainObjectBase<DerivedV>& V,
Eigen::PlainObjectBase<DerivedF>& F)
{
using namespace std;
using namespace Eigen;
Eigen::MatrixXd N;
vector<vector<double > > vV,vN,vTC,vC;
vector<vector<int > > vF,vFTC,vFN;
vector<tuple<string, int, int>> FM;
if(ext == "mesh")
{
// Convert extension to lower case
MatrixXi T;
if(!readMESH(fp,V,T,F))
{
return 1;
}
//if(F.size() > T.size() || F.size() == 0)
{
boundary_facets(T,F);
// outward facing
F = F.rowwise().reverse().eval();
}
}else if(ext == "obj")
{
if(!readOBJ(fp,vV,vTC,vN,vF,vFTC,vFN,FM))
{
return false;
}
// Annoyingly obj can store 4 coordinates, truncate to xyz for this generic
// read_triangle_mesh
for(auto & v : vV)
{
v.resize(std::min(v.size(),(size_t)3));
}
}else if(ext == "off")
{
if(!readOFF(fp,vV,vF,vN,vC))
{
return false;
}
}else if(ext == "ply")
{
return readPLY(fp, V, F);
}else if(ext == "stl")
{
if(!readSTL(fp,V,F,N))
{
return false;
}
}else if(ext == "wrl")
{
if(!readWRL(fp,vV,vF))
{
return false;
}
}else
{
cerr<<"Error: unknown extension: "<<ext<<endl;
return false;
}
if(vV.size() > 0)
{
if(!list_to_matrix(vV,V))
{
return false;
}
polygon_mesh_to_triangle_mesh(vF,F);
}
return true;
}
#endif
#ifdef IGL_STATIC_LIBRARY
// Explicit template instantiation
// generated by autoexplicit.sh
template bool igl::read_triangle_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<double, -1, -1, 1, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 1, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(std::string, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<float, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<float, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&);
template bool igl::read_triangle_mesh<Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<unsigned int, -1, 3, 1, -1, 3> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<unsigned int, -1, 3, 1, -1, 3> >&);
template bool igl::read_triangle_mesh<double, int>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::vector<double, std::allocator<double> >, std::allocator<std::vector<double, std::allocator<double> > > >&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >&);
#endif
| [
"tereshin.tesha@gmail.com"
] | tereshin.tesha@gmail.com |
302ea77ef78e52b2a640c45881435cec1d3e328d | f36f2f66492870e8fd84338a4bb98c5b67e4431c | /two_partitions/src/particle.cpp | 7b77ece649c43442f9bceb13026eba22c5c81755 | [] | no_license | cecilia-balocchi/particle-optimization | b607dcf514a60b814a5edc071d3f739da27b0dca | fcfad230f99350ec30d467685863b6d494280bf0 | refs/heads/master | 2022-12-12T08:14:38.277029 | 2022-12-08T16:47:00 | 2022-12-08T16:47:00 | 223,828,170 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 92,909 | cpp | /*
* particle.cpp
*
*/
#include <RcppArmadillo.h>
// [[Rcpp::depends(RcppArmadillo)]]
#include <Rcpp.h>
using namespace Rcpp;
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <iomanip>
#include <string.h>
#include <limits.h>
#include <armadillo>
#include <time.h>
#include <random>
#include "partition.h"
#include "particle.h"
#include "various_functions.h"
#include "partition_functions.h"
#include "particle_functions.h"
using namespace std;
using namespace arma;
extern arma::mat Y;
extern arma::mat X;
extern arma::mat A_block;
// Set the hyper-parameters
extern double rho;
// extern double a;
// extern double b;
extern double a1;
extern double a2;
extern double b1;
extern double b2;
extern double alpha_sigma;
extern double beta_sigma;
extern double eta;
extern int prior;
extern int opt_method;
extern int opt_Y;
extern int coordasc_iter;
extern double A_or_B_first;
extern int* sigma;
extern double split_frac;
extern double* alpha_mle;
extern double* beta_mle;
extern bool sampleA;
extern bool sampleB;
extern int kmeans_rep;
// extern double a_taualpha;
// extern double b_taualpha;
// extern double a_taubeta;
// extern double b_taubeta;
Particle::Particle(){
nObs = 0;
partition_A = NULL;
partition_B = NULL;
alpha = NULL;
beta = NULL;
I11 = NULL;
I12 = NULL;
I21 = NULL;
I22 = NULL;
// sigma = 1.0;
// tau_A = 1.0;
// tau_B = 1.0;
return;
}
Particle::Particle(LPParticle initial_particle){
nObs = initial_particle->nObs;
partition_A = new Partition(initial_particle->partition_A, 1);
partition_B = new Partition(initial_particle->partition_B, 0);
alpha = new double[nObs];
beta = new double[nObs];
for(int i = 0; i < nObs; i++){
alpha[i] = initial_particle->alpha[i];
beta[i] = initial_particle->beta[i];
}
if(opt_method == 1){
I11 = new arma::mat(nObs, nObs, fill::zeros);
I12 = new arma::mat(nObs, nObs, fill::zeros);
I21 = new arma::mat(nObs, nObs, fill::zeros);
I22 = new arma::mat(nObs, nObs, fill::zeros);
*I11 = 0 + *(initial_particle->I11);
*I12 = 0 + *(initial_particle->I12);
*I21 = 0 + *(initial_particle->I21);
*I22 = 0 + *(initial_particle->I22);
}
return;
}
Particle::~Particle(){
delete partition_A;
delete partition_B;
delete[] alpha;
delete[] beta;
partition_A = NULL;
partition_B = NULL;
alpha = NULL;
beta = NULL;
if(opt_method == 1){
delete I11;
delete I12;
delete I21;
delete I22;
I11 = NULL;
I12 = NULL;
I21 = NULL;
I22 = NULL;
}
return;
}
// copy particle is useful to use within a function of the class,
// when you want to delete this and the assign it a value
void Particle::Copy_Particle(LPParticle initial_particle){
nObs = initial_particle->nObs;
delete partition_A;
delete partition_B;
partition_A = new Partition(initial_particle->partition_A,1);
partition_B = new Partition(initial_particle->partition_B,0);
delete[] alpha;
delete[] beta;
alpha = new double[nObs];
beta = new double[nObs];
for(int i = 0; i < nObs; i++){
alpha[i] = initial_particle->alpha[i];
beta[i] = initial_particle->beta[i];
}
if(opt_method == 1){
delete I11;
delete I12;
delete I21;
delete I22;
I11 = new arma::mat(nObs, nObs, fill::zeros);
I12 = new arma::mat(nObs, nObs, fill::zeros);
I21 = new arma::mat(nObs, nObs, fill::zeros);
I22 = new arma::mat(nObs, nObs, fill::zeros);
*I11 = 0 + *(initial_particle->I11);
*I12 = 0 + *(initial_particle->I12);
*I21 = 0 + *(initial_particle->I21);
*I22 = 0 + *(initial_particle->I22);
}
return;
}
// void Particle::Initialize_Particle(int n){
// nObs = n;
// partition_A = new Partition;
// partition_B = new Partition;
// partition_A->Initialize_Partition(n, 1);
// partition_B->Initialize_Partition(n, 0);
// alpha = new double[nObs];
// beta = new double[nObs];
// if(opt_method == 1){
// I11 = new arma::mat(nObs, nObs, fill::zeros);
// I12 = new arma::mat(nObs, nObs, fill::zeros);
// I21 = new arma::mat(nObs, nObs, fill::zeros);
// I22 = new arma::mat(nObs, nObs, fill::zeros);
// }
// get_alpha_beta();
// return;
// }
void Particle::Initialize_Particle(int n, Rcpp::List gamma_init_A, Rcpp::List gamma_init_B){
nObs = n;
partition_A = new Partition;
partition_B = new Partition;
if(gamma_init_A.size() != 0){
partition_A->Initialize_Partition(n, gamma_init_A, 1);
} else {
partition_A->Initialize_Partition(n, 1);
}
if(gamma_init_B.size() != 0){
partition_B->Initialize_Partition(n, gamma_init_B, 0);
} else {
partition_B->Initialize_Partition(n, 0);
}
alpha = new double[nObs];
beta = new double[nObs];
if(opt_method == 1){
I11 = new arma::mat(nObs, nObs, fill::zeros);
I12 = new arma::mat(nObs, nObs, fill::zeros);
I21 = new arma::mat(nObs, nObs, fill::zeros);
I22 = new arma::mat(nObs, nObs, fill::zeros);
}
get_alpha_beta();
return;
}
void Particle::Initialize_Particle_nclusters(int n){
nObs = n;
partition_A = new Partition;
partition_B = new Partition;
partition_A->Initialize_Partition_nclusters(n, 1);
partition_B->Initialize_Partition_nclusters(n, 0);
alpha = new double[nObs];
beta = new double[nObs];
if(opt_method == 1){
I11 = new arma::mat(nObs, nObs, fill::zeros);
I12 = new arma::mat(nObs, nObs, fill::zeros);
I21 = new arma::mat(nObs, nObs, fill::zeros);
I22 = new arma::mat(nObs, nObs, fill::zeros);
}
get_alpha_beta();
return;
}
void Particle::get_alpha_beta(){
int T = Y.n_cols;
mat E = eye<mat>(nObs,nObs);
mat O = ones<mat>(nObs,nObs);
mat Z = zeros<mat>(nObs,nObs);
mat O_k, A_block_k, Omega_k, D, M;
mat Omega_a = zeros<mat>(nObs,nObs);
mat Omega_b = zeros<mat>(nObs,nObs);
// I am updating Omega_a (the inverse of the covariance matrix of alpha) cluster-wise
for(int k = 0; k < partition_A->K; k++){
int cluster_size = partition_A->cluster_config[k];
if(cluster_size == 1){
Omega_a(partition_A->clusters[k][0], partition_A->clusters[k][0]) = 1/(a1/(1-rho)+a2);
} else {
O_k = ones<mat>(cluster_size,cluster_size);
// Creating M: the precision matrix of the CAR model
A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_A->clusters[k], partition_A->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
D = diagmat(row_sums);
M = rho * (D - A_block_k);
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// This is the Woodbury matrix identity for inversion
// Omega_k = (M/a1) - (M/a1) * O_k * (M/a1) / (sum(sum(M))/a1 + 1/a2);
Omega_k = (M/a1) - ((1-rho)/a1)*((1-rho)/a1) / ( cluster_size*(1-rho)/a1 + 1/a2) * O_k;
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
Omega_a(partition_A->clusters[k][i], partition_A->clusters[k][j]) = Omega_k(i,j);
}
}
}
}
// I am updating Omega_b (the inverse of the covariance matrix of beta) cluster-wise
for(int k = 0; k < partition_B->K; k++){
int cluster_size = partition_B->cluster_config[k];
if(cluster_size == 1){
Omega_b(partition_B->clusters[k][0], partition_B->clusters[k][0]) = 1/(b1/(1-rho)+b2);
} else {
O_k = ones<mat>(cluster_size,cluster_size);
// Creating M: the precision matrix of the CAR model
A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_B->clusters[k], partition_B->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
D = diagmat(row_sums);
M = rho * (D - A_block_k);
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// This is the Woodbury matrix identity for inversion
// Omega_k = (M/b1) - (M/b1) * O_k * (M/b1) / (sum(sum(M))/b1 + 1/b2);
Omega_k = (M/b1) - ((1-rho)/b1)*((1-rho)/b1) / ( cluster_size*(1-rho)/b1 + 1/b2) * O_k;
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
Omega_b(partition_B->clusters[k][i], partition_B->clusters[k][j]) = Omega_k(i,j);
}
}
}
}
arma::mat sumX = diagmat(sum(X,1));
arma::mat sumX2 = diagmat(sum(X%X,1));
vec xty1 = sum(Y,1);
vec xty2 = sum(X%Y,1);
arma::vec XtY = arma::join_cols(xty1,xty2);
// mat Sigma0inv = arma::join_cols(arma::join_rows(Omega_a, Z),arma::join_rows(Z, Omega_b));
// mat XtX = arma::join_cols(arma::join_rows(E*T, E*sum(x)),arma::join_rows(E*sum(x), E*sum(x2)));
// mat P = inv_sympd(XtX + Sigma0inv); // this should be replaced with the block inversion formula
mat P;
if(opt_method == 1){
P = block_inverse_ret(E*T + Omega_a, sumX, sumX, sumX2+Omega_b, I11, I12, I21, I22);
} else {
mat L11, L12, L21, L22;
P = block_inverse_ret(E*T + Omega_a, sumX, sumX, sumX2+Omega_b, &L11, &L12, &L21, &L22);
}
vec alpha_beta = P * XtY;
for(int i = 0; i < nObs; i++){
alpha[i] = alpha_beta(i);
beta[i] = alpha_beta(i+nObs);
}
return;
}
void Particle::get_alpha_beta_mle(double* alpha_mle, double* beta_mle){
double a1 = 100;
double a2 = 100;
double b1 = 100;
double b2 = 100;
int T = Y.n_cols;
mat E = eye<mat>(nObs,nObs);
mat O = ones<mat>(nObs,nObs);
mat Z = zeros<mat>(nObs,nObs);
mat O_k, A_block_k, Omega_k, D, M;
mat Omega_a = zeros<mat>(nObs,nObs);
mat Omega_b = zeros<mat>(nObs,nObs);
// I am updating Omega_a (the inverse of the covariance matrix of alpha) cluster-wise
for(int k = 0; k < partition_A->K; k++){
int cluster_size = partition_A->cluster_config[k];
if(cluster_size == 1){
Omega_a(partition_A->clusters[k][0], partition_A->clusters[k][0]) = 1/(a1/(1-rho)+a2);
} else {
O_k = ones<mat>(cluster_size,cluster_size);
// Creating M: the precision matrix of the CAR model
A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_A->clusters[k], partition_A->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
D = diagmat(row_sums);
M = rho * (D - A_block_k);
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// This is the Woodbury matrix identity for inversion
// Omega_k = (M/a1) - (M/a1) * O_k * (M/a1) / (sum(sum(M))/a1 + 1/a2);
Omega_k = (M/a1) - ((1-rho)/a1)*((1-rho)/a1) / ( cluster_size*(1-rho)/a1 + 1/a2) * O_k;
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
Omega_a(partition_A->clusters[k][i], partition_A->clusters[k][j]) = Omega_k(i,j);
}
}
}
}
// I am updating Omega_b (the inverse of the covariance matrix of beta) cluster-wise
for(int k = 0; k < partition_B->K; k++){
int cluster_size = partition_B->cluster_config[k];
if(cluster_size == 1){
Omega_b(partition_B->clusters[k][0], partition_B->clusters[k][0]) = 1/(b1/(1-rho)+b2);
} else {
O_k = ones<mat>(cluster_size,cluster_size);
// Creating M: the precision matrix of the CAR model
A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_B->clusters[k], partition_B->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
D = diagmat(row_sums);
M = rho * (D - A_block_k);
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// This is the Woodbury matrix identity for inversion
// Omega_k = (M/b1) - (M/b1) * O_k * (M/b1) / (sum(sum(M))/b1 + 1/b2);
Omega_k = (M/b1) - ((1-rho)/b1)*((1-rho)/b1) / ( cluster_size*(1-rho)/b1 + 1/b2) * O_k;
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
Omega_b(partition_B->clusters[k][i], partition_B->clusters[k][j]) = Omega_k(i,j);
}
}
}
}
arma::mat sumX = diagmat(sum(X,1));
arma::mat sumX2 = diagmat(sum(X%X,1));
vec xty1 = sum(Y,1);
vec xty2 = sum(X%Y,1);
arma::vec XtY = arma::join_cols(xty1,xty2);
// mat Sigma0inv = arma::join_cols(arma::join_rows(Omega_a, Z),arma::join_rows(Z, Omega_b));
// mat XtX = arma::join_cols(arma::join_rows(E*T, E*sum(x)),arma::join_rows(E*sum(x), E*sum(x2)));
// mat P = inv_sympd(XtX + Sigma0inv); // this should be replaced with the block inversion formula
mat P;
if(opt_method == 1){
P = block_inverse_ret(E*T + Omega_a, sumX, sumX, sumX2+Omega_b, I11, I12, I21, I22);
} else {
mat L11, L12, L21, L22;
P = block_inverse_ret(E*T + Omega_a, sumX, sumX, sumX2+Omega_b, &L11, &L12, &L21, &L22);
}
vec alpha_beta = P * XtY;
for(int i = 0; i < nObs; i++){
alpha_mle[i] = alpha_beta(i);
beta_mle[i] = alpha_beta(i+nObs);
}
return;
}
void Particle::get_alpha_beta_iter(){
LPPartition partition;
for(int iter = 0; iter < coordasc_iter; iter++){
partition = partition_A;
for(int k = 0; k < partition->K; k++){
get_parameter(1,k);
}
partition = partition_B;
for(int k = 0; k < partition->K; k++){
get_parameter(0,k);
}
}
}
void Particle::get_parameter(bool A_or_B, int cluster_id){
if(A_or_B){
int T = Y.n_cols;
int cluster_size = partition_A->cluster_config[cluster_id];
double txx = T; // this is correct for A_or_B = 1
if(cluster_size == 1){
vec y_adj(T);
for(int t = 0; t < T; t++){
// y_adj(t) = Y(partition_A->clusters[cluster_id][0],t); // they are equivalent when X is orthogonal
y_adj(t) = Y(partition_A->clusters[cluster_id][0],t) - X(partition_A->clusters[cluster_id][0],t)*beta[partition_A->clusters[cluster_id][0]];
}
double Omega_beta_k = 1/(a1 + a2);
double tXY = sum(y_adj);
alpha[partition_A->clusters[cluster_id][0]] = 1/(txx + Omega_beta_k) * tXY;
} else {
mat O = ones<mat>(cluster_size, cluster_size);
mat E = eye<mat>(cluster_size, cluster_size);
mat A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_A->clusters[cluster_id], partition_A->clusters[cluster_id]);
// get rowsums
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
mat D = diagmat(row_sums);
mat A_star_k = D - A_block_k;
mat M = rho * A_star_k;
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// mat Sigma0inv = (M/a1) - (M/a1) * O * (M/a1) / (sum(sum(M))/a1 + 1/a2);
mat Sigma0inv = (M/a1) - ((1-rho)/a1)*((1-rho)/a1) / ( cluster_size*(1-rho)/a1 + 1/a2) * O;
mat Y_adj = zeros<mat>(cluster_size,T);
for(int i = 0; i < cluster_size; i++){
// Y_adj.row(i) = Y.row(partition_A->clusters[cluster_id][i]); // they are equivalent when X is orthogonal
Y_adj.row(i) = Y.row(partition_A->clusters[cluster_id][i]) - X.row(partition_A->clusters[cluster_id][i])*beta[partition_A->clusters[cluster_id][i]];
}
vec tXY = sum(Y_adj, 1);
mat tXX = E * txx;
mat temp = inv_sympd(tXX + Sigma0inv);
vec tmp_alpha = temp * tXY;
for(int i = 0; i < cluster_size; i++){
alpha[partition_A->clusters[cluster_id][i]] = tmp_alpha(i);
}
}
} else {
int T = Y.n_cols;
int cluster_size = partition_B->cluster_config[cluster_id];
if(cluster_size == 1){
vec y_adj(T);
int i = partition_B->clusters[cluster_id][0];
for(int t = 0; t < T; t++){
// y_adj(t) = Y(i,t); // they are equivalent when X is orthogonal
y_adj(t) = Y(i,t) - alpha[i];
}
double Omega_beta_k = 1/(b1 + b2);
double tXY = as_scalar(X.row(i) * y_adj);
double txx = as_scalar(X.row(i) * (X.row(i)).t());
beta[i] = 1/(txx + Omega_beta_k) * tXY;
} else {
mat O = ones<mat>(cluster_size, cluster_size);
// mat E = eye<mat>(cluster_size, cluster_size);
mat A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_B->clusters[cluster_id], partition_B->clusters[cluster_id]);
// get rowsums
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
mat D = diagmat(row_sums);
mat A_star_k = D - A_block_k;
mat M = rho * A_star_k;
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// mat Sigma0inv = (M/b1) - (M/b1) * O * (M/b1) / (sum(sum(M))/b1 + 1/b2);
mat Sigma0inv = (M/b1) - ((1-rho)/b1)*((1-rho)/b1) / ( cluster_size*(1-rho)/b1 + 1/b2) * O;
mat Y_adj = zeros<mat>(cluster_size,T);
mat XtY = zeros<mat>(cluster_size,T);
mat tXX = eye<mat>(cluster_size, cluster_size);
// this could change: we could have only the vector tXY and inside the loop..
for(int i = 0; i < cluster_size; i++){
// Y_adj.row(i) = Y.row(partition_B->clusters[cluster_id][i]); // they are equivalent when X is orthogonal
Y_adj.row(i) = Y.row(partition_B->clusters[cluster_id][i]) - alpha[partition_B->clusters[cluster_id][i]];
XtY.row(i) = X.row(partition_B->clusters[cluster_id][i]) % Y_adj.row(i);
tXX(i,i) = sum( X.row(partition_B->clusters[cluster_id][i]) % X.row(partition_B->clusters[cluster_id][i]) );
// here we could do tXY(i) = sum(x % Y_adj.row(i));
}
vec tXY = sum(XtY, 1);
mat temp = inv_sympd(tXX + Sigma0inv);
vec tmp_beta = temp * tXY;
for(int i = 0; i < cluster_size; i++){
beta[partition_B->clusters[cluster_id][i]] = tmp_beta(i);
}
}
}
return;
}
// if A_or_B = True we do A
void Particle::Partition_Split(bool A_or_B, int split_k, int* new_cluster1, int* new_cluster2, int size1, int size2){
int orig_K;
if(A_or_B == true){
orig_K = partition_A->K;
partition_A->Split(split_k, new_cluster1, new_cluster2, size1, size2, A_or_B);
} else {
orig_K = partition_B->K;
partition_B->Split(split_k, new_cluster1, new_cluster2, size1, size2, A_or_B);
}
if(opt_method == 0){
// just do what we were doing before
for(int k = 0; k < orig_K+1; k++){
if(k == split_k){ // need to re-compute
get_parameter(A_or_B, k);
} else if(k == orig_K){
get_parameter(A_or_B, k);
}
}
} else if(opt_method == 1){
// optimize alpha_beta given the two partitions
get_alpha_beta();
} else if(opt_method == 2){
// optimize alpha_beta given the two partitions, by doing coordinate ascend
get_alpha_beta_iter();
}
return;
}
void Particle::Partition_Split(bool A_or_B, int split_k, std::vector<int> new_cluster1, std::vector<int> new_cluster2, int size1, int size2){
int orig_K;
if(A_or_B == true){
orig_K = partition_A->K;
partition_A->Split(split_k, new_cluster1, new_cluster2, size1, size2, A_or_B);
} else {
orig_K = partition_B->K;
partition_B->Split(split_k, new_cluster1, new_cluster2, size1, size2, A_or_B);
}
if(opt_method == 0){
// just do what we were doing before
for(int k = 0; k < orig_K+1; k++){
if(k == split_k){ // need to re-compute
get_parameter(A_or_B, k);
} else if(k == orig_K){
get_parameter(A_or_B, k);
}
}
} else if(opt_method == 1){
// optimize alpha_beta given the two partitions
get_alpha_beta();
} else if(opt_method == 2){
// optimize alpha_beta given the two partitions, by doing coordinate ascend
get_alpha_beta_iter();
}
return;
}
void Particle::Partition_KSplit(bool A_or_B, int split_k, std::vector<std::vector<int> > indices, std::vector<int> ns){
int num_splits = indices.size();
if(num_splits != (int)ns.size()){
cout << "Partition_KSplit: ERROR, ns.size should be equal to indices.size()" << endl;
}
int orig_K;
if(A_or_B == true){
orig_K = partition_A->K;
partition_A->KSplit(split_k, num_splits, indices, ns, A_or_B);
} else {
orig_K = partition_B->K;
partition_B->KSplit(split_k, num_splits, indices, ns, A_or_B);
}
if(opt_method == 0){
// just re-compute for the new clusters
int new_K = orig_K + num_splits - 1;
for(int k = 0; k < new_K; k++){
if(k == split_k){
get_parameter(A_or_B, k);
} else if(k >= orig_K){
get_parameter(A_or_B, k);
}
}
} else if(opt_method == 1){
// optimize alpha_beta given the two partitions
get_alpha_beta();
} else if(opt_method == 2){
// optimize alpha_beta given the two partitions, by doing coordinate ascend
get_alpha_beta_iter();
}
return;
}
void Particle::Partition_Merge(bool A_or_B, int k_1, int k_2){
// int k_max = max(k_1, k_2);
int k_min = min(k_1, k_2);
int orig_K;
if(A_or_B == true){
orig_K = partition_A->K;
partition_A->Merge(k_1, k_2, A_or_B);
} else {
orig_K = partition_B->K;
partition_B->Merge(k_1, k_2, A_or_B);
}
if(opt_method == 0){
// just do what we were doing before
for(int k = 0; k < orig_K; k++){
if(k == k_min){
get_parameter(A_or_B, k);
}
}
} else if(opt_method == 1){
// optimize alpha_beta given the two partitions
get_alpha_beta();
} else if(opt_method == 2){
// optimize alpha_beta given the two partitions, by doing coordinate ascend
get_alpha_beta_iter();
}
return;
}
void Particle::Partition_Split_and_Merge(bool A_or_B, int split_k, int* new_cluster1, int* new_cluster2, int size1, int size2, int k_star_1, int k_star_2){
// this should be good, so they are pointing at the same thing.
LPPartition partition;
if(A_or_B){
partition = partition_A;
} else {
partition = partition_B;
}
if(k_star_1 != k_star_2){
Partition_Split(A_or_B, split_k, new_cluster1, new_cluster2, size1, size2);
if((split_k == k_star_1) & (split_k != k_star_2)){ // leave new_cluster1 alone and just attempt to merge new_cluster2 with k_star_2
Partition_Merge(A_or_B, partition->K-1, k_star_2); // remember new_cluster2's label is K-1
} else if( (split_k != k_star_1) & (split_k == k_star_2)){
Partition_Merge(A_or_B, split_k, k_star_1);
} else if((split_k != k_star_1) & (split_k != k_star_2) & (k_star_2 > max(split_k, k_star_1))){
Partition_Merge(A_or_B, split_k, k_star_1);
Partition_Merge(A_or_B, partition->K, k_star_2 - 1);
} else if((split_k != k_star_1) & (split_k != k_star_2) & (k_star_2 < max(split_k, k_star_1))){
Partition_Merge(A_or_B, split_k, k_star_1);
Partition_Merge(A_or_B, partition->K, k_star_2);
}
}
return;
}
void Particle::Partition_Modify(bool A_or_B, int cl_ind){
// this should be good, so they are pointing at the same thing.
LPPartition partition;
if(A_or_B){
partition = partition_A;
} else {
partition = partition_B;
}
// cl_ind is the index of the cluster that needs to be modified
if(partition->cluster_config[cl_ind] > 1)
{
int n = partition->cluster_config[cl_ind];
int *index = partition->clusters[cl_ind];
mat A_cluster = Submatrix(A_block, n, n, index, index);
int *components = new int[n];
int *count = new int;
Connected_Components(A_cluster, n, components, count);
if(*count > 1)
{
//I will use split iteratively, first split 0 from !=0
//then among the remaining, split 1 from !=1, etc
*count = *count - 1;
int *new_components, *index1, *index2, *i_ind, n1, n2;
for(int tmp = 0; tmp < *count; tmp++)
{
index1 = new int[n];
index2 = new int[n];
i_ind = new int[n];
n1 = 0;
n2 = 0;
for(int i = 0; i < n; i++){
if(components[i] == tmp){
index1[n1] = index[i];
n1++;
} else {
index2[n2] = index[i];
i_ind[n2] = i;
n2++;
}
}
Partition_Split(A_or_B, cl_ind, index1, index2, n1, n2);
if(tmp > 0)
delete[] index;
index = index2;
n = n2;
new_components = new int[n2];
for(int j = 0; j < n2; j++)
new_components[j] = components[i_ind[j]];
delete[] components;
components = new_components;
cl_ind = partition->K-1;
delete[] index1;
}
delete[] index2;
}
delete[] components;
delete count;
}
}
// find splits needs more work, because of all the computation
// same for ksplits
void Particle::Update_Partition(bool A_or_B, int current_l, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, bool restricted){
string max_str = "Not changed";
LPParticle max_candidate;
max_candidate = new Particle(this); // holds the running "best local candidate"
double max_objective = 0.0;
max_objective = w[current_l]*max_candidate->Total_Log_Post() + lambda * Entropy(current_l, max_candidate, Particle_Set, w) + xi * VI_Avg(current_l, max_candidate, Particle_Set);
if(!A_or_B){
cout << max_candidate->Total_Log_Post() << " ";
}
if(!restricted){
// Islands - 5% in each cluster
// cout << "before island" << endl;
Island_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str);
// cout << "before border" << endl;
Border_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str);
// Merges: Sweep over all clusters and find the ones that are adjacent
// cout << "before merge" << endl;
Merge_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str);
// we will loop over the clusters, run spectral clustering on the beta_hat's within the cluster, and propose various split and merge candidates
// cout << "before splitmerge" << endl;
Spectral_SplitMerge_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str);
Spectral_SplitMerge_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str, true);
// cout << "before tailsplit" << endl;
Tail_Split_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str);
}
// cout << "before km" << endl;
KM_SplitMerge_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str);
KM_SplitMerge_moves(A_or_B, &max_objective, current_l, max_candidate, Particle_Set, w, lambda, xi, &max_str, true);
// cout << "after km" << endl;
Copy_Particle(max_candidate);
cout << max_str << " " << max_objective << " ";
if(!A_or_B){
cout << "- " << max_candidate->Total_Log_Post();
}
cout << endl;
delete max_candidate;
return;
}
std::vector<int> Particle::get_jstar(bool A_or_B, int split_k, int num_splits, std::vector< std::vector<int> > indices, std::vector<int> ns){
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
std::vector<std::vector<int> > adj_clusters;
std::vector<int> jstar(num_splits);
double beta_bar, tmp, tmp_min;
adj_clusters.resize(num_splits);
arma::mat tmp_A;
for(int j = 0; j < num_splits; j++){
arma::vec param_cluster_vec(ns[j]);
for(int i = 0; i < ns[j]; i++){
param_cluster_vec(i) = parameter[ indices[j][i] ];
}
beta_bar = arma::mean(param_cluster_vec);
for(int kk = 0; kk < partition->K; kk++){
if(kk != split_k){
tmp_A = Submatrix(A_block, ns[j], partition->cluster_config[kk], indices[j], partition->clusters[kk]);
if(any(vectorise(tmp_A == 1.0))){
adj_clusters[j].push_back(kk);
}
}
}
if((int)adj_clusters[j].size() > 0){ // find jstar (the closest in mean adjacent cluster)
tmp_min = abs(param_bar(A_or_B, adj_clusters[j][0])-beta_bar);
jstar[j] = adj_clusters[j][0];
for(int ii = 1; ii < (int)adj_clusters[j].size(); ii++){
tmp = abs(param_bar(A_or_B, adj_clusters[j][ii])-beta_bar);
if(tmp < tmp_min){
tmp_min = tmp;
jstar[j] = adj_clusters[j][ii];
}
}
} else { // -1 means no adjacent cluster
jstar[j] = -1;
}
}
return jstar;
}
std::vector<int> Particle::get_tail_jstar(bool A_or_B, int split_k, std::vector<std::vector<int> > tail_conncomp){
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
std::vector<int> left_jstar;
arma::vec param_cluster;
double param_mean;
std::vector<double> tmp_dist; // holds distance from the new sub-clusters to adjacent existing clusters
std::vector<double> tmp_nn; // holds indices of potential nearest neighbors for new sub-clusters
arma::vec tmp_dist_vec; // arma vector version of tmp_dist
arma::uvec tmp_dist_indices; // for soring tmp_dist_vec
arma::mat A_tmp;
for(int new_k = 0; new_k < (int)tail_conncomp.size(); new_k++){
// now figure out the connected components
param_cluster.clear();
param_cluster.set_size( tail_conncomp[new_k].size() );
for(int j = 0; j < (int)tail_conncomp[new_k].size(); j++){
param_cluster(j) = parameter[ tail_conncomp[new_k][j] ];
}
param_mean = arma::mean(param_cluster);
tmp_nn.clear();
tmp_dist.clear();
for(int kk = 0; kk < partition->K; kk++){
if(kk != split_k){
A_tmp = Submatrix(A_block, tail_conncomp[new_k].size(), partition->cluster_config[kk], tail_conncomp[new_k], partition->clusters[kk]);
if(any(vectorise(A_tmp == 1.0))){
tmp_nn.push_back(kk);
param_cluster.clear();
param_cluster.set_size( partition->cluster_config[kk] );
for(int j = 0; j < partition->cluster_config[kk]; j++){
param_cluster(j) = parameter[ partition->clusters[kk][j] ];
}
tmp_dist.push_back(abs(param_mean - arma::mean(param_cluster)));
}
}
}
if(tmp_nn.size() > 0){
tmp_dist_vec.reset();
tmp_dist_indices.reset();
tmp_dist_vec.set_size(tmp_dist.size());
tmp_dist_indices.set_size(tmp_dist.size());
for(int kk = 0; kk < (int)tmp_dist.size(); kk++){
tmp_dist_vec(kk) = tmp_dist[kk];
}
tmp_dist_indices = sort_index(tmp_dist_vec,"ascend");
left_jstar.push_back(tmp_nn[tmp_dist_indices(0)]);
} else{
left_jstar.push_back(-1);
}
}
return left_jstar;
}
void Particle::Island_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr, double percentage){
// cout << "START ISLAND" << endl;
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
double tmp_objective = 0.0;
int split_k, size1, size2;
// int* new_cluster1;
// int* new_cluster2;
// new_cluster1 = new int[1];
// new_cluster2 = new int[1];
LPParticle tmp_candidate = new Particle(this);
for(int k = 0; k < partition->K; k++){
// cout << "*Start cluster " << k << endl;
// find which elements are in the top - bottom 5%
if(partition->cluster_config[k] > 1){
double* beta_hat_copy = new double[ partition->cluster_config[k] ];
for(int i = 0; i < partition->cluster_config[k]; i++){
beta_hat_copy[i] = parameter[ partition->clusters[k][i] ];
}
sort(beta_hat_copy, beta_hat_copy + partition->cluster_config[k]);
int threshold = (int) ceil(partition->cluster_config[k] * percentage);
// std::vector<int> index_topbottom(2*threshold);
std::vector<int> index_topbottom;
index_topbottom.reserve(2*threshold);
// int *index_topbottom = new int[2*threshold];
// int count = 0;
for(int i = 0; i < threshold; i++){
for(int j = 0; j < partition->cluster_config[k]; j++){
if(parameter[ partition->clusters[k][j] ] == beta_hat_copy[i]){
index_topbottom.push_back(partition->clusters[k][j]);
// count ++;
}
}
for(int j = 0; j < partition->cluster_config[k]; j++){
if(parameter[ partition->clusters[k][j] ] == beta_hat_copy[(partition->cluster_config[k])-1-i]){
index_topbottom.push_back(partition->clusters[k][j]);
// count ++;
}
}
}
// index_topbottom contains the index in the whole city like {1, ..255}, not the index in the cluster
delete[] beta_hat_copy;
// cout << "*Done index - 2*threshold: " << 2*threshold << " and index_topbottom.size() " << index_topbottom.size() << endl;
for(int c = 0; c < 2*threshold; c++){
// cout << "**Start element " << c << endl;
int i = index_topbottom[c];
// cout << "after i" << endl;
split_k = k;
delete tmp_candidate; // delete the old value of tmp_candidate .. i can either use Copy_Partition or do a delete[] and new call
// cout << "after delete tmp_candidate" << endl;
tmp_candidate = new Particle(this);
// cout << "after new Particle" << endl;
size1 = partition->cluster_config[split_k] - 1;
size2 = 1;
std::vector<int> new_cluster1;
std::vector<int> new_cluster2(size2);
new_cluster1.reserve(size1);
new_cluster2[0] = i;
for(int ii = 0; ii < partition->cluster_config[split_k]; ii++){
if(partition->clusters[split_k][ii] != i){
new_cluster1.push_back(partition->clusters[split_k][ii]);
}
}
// now actually perform the split
tmp_candidate->Partition_Split(A_or_B, split_k, new_cluster1, new_cluster2, size1, size2);
tmp_candidate->Partition_Modify(A_or_B, split_k);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
try{
max_candidate = new Particle(tmp_candidate);
}
catch(const std::bad_alloc& e){
cout << "######## EXCEPTION 4 ########" << e.what() << endl;
}
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "Island";
}
}
}
}
delete tmp_candidate;
// delete[] new_cluster1;
// delete[] new_cluster2;
// cout << "END ISLAND" << endl;
return;
}
void Particle::Border_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr){
LPPartition partition;
// double* parameter;
if(A_or_B){
partition = partition_A;
// parameter = alpha;
} else {
partition = partition_B;
// parameter = beta;
}
double tmp_objective = 0.0;
int split_k, k_star_1, k_star_2;
std::vector<int> neighboring_clusters; // holds the labels of clusters adjacent to block-group i
int neighbor_counter = 0;
int size1, size2;
int* new_cluster1;
int* new_cluster2;
new_cluster1 = new int[1];
new_cluster2 = new int[1];
LPParticle tmp_candidate = new Particle(this);
for(int i = 0; i < partition->nObs; i++){
split_k = partition->cluster_assignment[i];
if(partition->cluster_config[split_k] > 1){ // only attempt if there are at least 2 elements in that cluster. Otherwise this is just a Merge move
neighbor_counter = 0;
neighboring_clusters.clear();
for(int k = 0; k < partition->K;k++){
if(k != split_k){ // loop over the elements of cluster k to see if any are adjacent to i
for(int j = 0; j < partition->cluster_config[k]; j++){
if(A_block(i, partition->clusters[k][j]) == 1){ // j^th blockgroup of cluster k is adjacent to block group i
neighboring_clusters.push_back(k); // add k to the vector of adjacent
neighbor_counter++;
break; // once we know that i is adjacent to something in cluster k we can stop
}
}
}
}
if(neighbor_counter > 0){
// we are splitting i away from its cluster
// let us define all of the necessary components for that split
size1 = partition->cluster_config[split_k] - 1;
size2 = 1;
delete[] new_cluster1;
delete[] new_cluster2;
try{
new_cluster1 = new int[size1];
new_cluster2 = new int[size2];
}
catch(const std::bad_alloc& e){
cout << "######## EXCEPTION 34b ########" << e.what() << endl;
}
new_cluster2[0] = i;
int counter = 0;
for(int ii = 0; ii < partition->cluster_config[split_k]; ii++){
if(partition->clusters[split_k][ii] != i){
new_cluster1[counter] = partition->clusters[split_k][ii];
counter++;
}
}
// new_cluster1 contains all of the things in cluster split_k EXCEPT for i
// it will be "merged" with itself (i.e. k_star_1 = split_k)
k_star_1 = split_k;
for(int nc = 0; nc < neighbor_counter; nc++){
k_star_2 = neighboring_clusters[nc]; // this is the new cluster that we are adding i to!
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Partition_Split_and_Merge(A_or_B, split_k, new_cluster1, new_cluster2, size1, size2, k_star_1, k_star_2);
tmp_candidate->Partition_Modify(A_or_B, split_k);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
// cout << tmp_objective << endl;
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
try{
max_candidate = new Particle(tmp_candidate);
}
catch(const std::bad_alloc& e){
cout << "######## EXCEPTION 6 ########" << e.what() << endl;
}
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "Border";
}
} // closes loop over the neighboring clusters
} // closes if statement that checks if there are neighboring clusters
} // closes if cluster_config>1
} // closes loop over the blockgroups
delete tmp_candidate;
delete[] new_cluster1;
delete[] new_cluster2;
return;
}
void Particle::Merge_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr){
// cout << "START MERGE" << endl;
LPPartition partition;
// double* parameter;
if(A_or_B){
partition = partition_A;
// parameter = alpha;
} else {
partition = partition_B;
// parameter = beta;
}
arma::mat tmp_A;
bool adj_clusters;
double tmp_objective = 0.0;
LPParticle tmp_candidate = new Particle(this);
if(partition->K > 1){ // only makes sense to merge clusters if there are at least 2
for(int k = 0; k < partition->K - 1 ; k++){
for(int kk = k+1; kk < partition->K; kk++){
// cout << "Start Clusters " << k << " and " << kk << endl;
tmp_A = Submatrix(A_block, partition->cluster_config[k], partition->cluster_config[kk], partition->clusters[k], partition->clusters[kk]);
// check if any element of tmp_A is equal to
adj_clusters = any(vectorise(tmp_A == 1.0));
if(adj_clusters){ // propose merging clusters k and kk!
delete tmp_candidate;
tmp_candidate = new Particle(this);
// cout << "before merge" << endl;
tmp_candidate->Partition_Merge(A_or_B,k,kk);
// cout << "after merge" << endl;
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
// cout << "after tmp_objective" << endl;
// cout << tmp_objective << endl;
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
try{
max_candidate = new Particle(tmp_candidate);
}
catch(const std::bad_alloc& e){
cout << "######## EXCEPTION 8 ########" << e.what() << endl;
}
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "Merge";
} // closes if statement that updates max_candidate
} // closes if statement that proposes the merge
// cout << "Start Clusters " << k << " and " << kk << endl;
} // closes inner loop over remaining clusters
} // closes outer loop over clusters
}
delete tmp_candidate;
// cout << "END MERGE" << endl;
return;
}
void Particle::Spectral_SplitMerge_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr, bool use_mle){
LPPartition partition;
// double* parameter;
if(A_or_B){
partition = partition_A;
// parameter = alpha;
} else {
partition = partition_B;
// parameter = beta;
}
double tmp_objective = 0.0;
int max_splits, n_cl;
std::vector<std::vector<int> > indices; // indices contains numbers between 0 and nObs-1
std::vector<int> ns;
LPParticle tmp_candidate = new Particle(this);
for(int split_k = 0; split_k < partition->K; split_k++){
if(partition->cluster_config[split_k] > 2){
n_cl = partition->cluster_config[split_k];
if(ceil(split_frac * sqrt(n_cl)) <= 2) max_splits = 3;
else max_splits = ceil(split_frac * sqrt(n_cl));
for(int num_splits = 2; num_splits < max_splits; num_splits++){
if(n_cl > num_splits){
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_objective = 0.0;
// now just try splitting
tmp_candidate->Find_K_SpectralSplits(A_or_B, split_k, num_splits, indices, ns, use_mle);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "Split";
if(use_mle){
*pt_maxstr = "SplitMle";
}
}
// now do the split and merge part
if(partition->K>1){
std::vector<int> jstar = get_jstar(A_or_B, split_k, num_splits, indices, ns);
int to_be_merged;
for(int j = 0; j < num_splits; j++){
if(jstar[j] != -1){
// the new cluster j is now in position 'to_be_merged':
if(j == 0){
to_be_merged = split_k;
} else {
to_be_merged = partition->K + j - 1;
}
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns);
tmp_candidate->Partition_Merge(A_or_B, to_be_merged, jstar[j]);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "SplitMerge";
if(use_mle){
*pt_maxstr = "SplitMergeMle";
}
}
}
} // close FOR over new clusters
} // close IF for split-merge
for(int c = 0; c < (int)indices.size(); c++){
indices[c].clear();
}
indices.clear();
} // close IF n_cl > num_splits
} // close FOR num_split
} // close IF at least two elements
} // close FOR for split_k
delete tmp_candidate;
return;
}
void Particle::KM_SplitMerge_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr, bool use_mle){
LPPartition partition;
// double* parameter;
if(A_or_B){
partition = partition_A;
// parameter = alpha;
} else {
partition = partition_B;
// parameter = beta;
}
double tmp_objective = 0.0;
int max_splits, n_cl;
std::vector<std::vector<int> > indices; // indices contains numbers between 0 and nObs-1
std::vector<int> ns;
LPParticle tmp_candidate = new Particle(this);
for(int split_k = 0; split_k < partition->K; split_k++){
if(partition->cluster_config[split_k] > 2){
n_cl = partition->cluster_config[split_k];
if(ceil(split_frac * sqrt(n_cl)) <= 2) max_splits = 3;
else max_splits = ceil(split_frac * sqrt(n_cl));
for(int num_splits = 2; num_splits < max_splits; num_splits++){
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_objective = 0.0;
// now just try splitting
tmp_candidate->Find_KM_Splits(A_or_B, split_k, num_splits, indices, ns, use_mle);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "KM Split";
if(use_mle){
*pt_maxstr = "KM SplitMle";
}
}
// now do the split and merge part
if(partition->K>1){
std::vector<int> jstar = get_jstar(A_or_B, split_k, num_splits, indices, ns);
int to_be_merged;
for(int j = 0; j < num_splits; j++){
if(jstar[j] != -1){
// the new cluster j is now in position 'to_be_merged':
if(j == 0){
to_be_merged = split_k;
} else {
to_be_merged = partition->K + j - 1;
}
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns);
tmp_candidate->Partition_Merge(A_or_B, to_be_merged, jstar[j]);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "KM SplitMerge";
if(use_mle){
*pt_maxstr = "KM SplitMergeMle";
}
}
}
} // close FOR over new clusters
} // close IF for split-merge
for(int c = 0; c < (int)indices.size(); c++){
indices[c].clear();
}
indices.clear();
} // close FOR num_split
} // close IF at least two elements
} // close FOR for split_k
delete tmp_candidate;
return;
}
void Particle::Tail_Split_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr){
LPPartition partition;
// double* parameter;
if(A_or_B){
partition = partition_A;
// parameter = alpha;
} else {
partition = partition_B;
// parameter = beta;
}
double tmp_objective = 0.0;
std::vector<std::vector<int> > indices;
std::vector<int> ns;
std::vector<std::vector<int> > left_center_right;
int to_be_merged;
// to determine the connected components
std::vector<std::vector<int> > left_conncomp; // holds the connected components of sub_left_tail
std::vector<std::vector<int> > right_conncomp; // holds the connected components of sub_left_tail
std::vector<int> left_k_star;
std::vector<int> right_k_star;
LPParticle tmp_candidate = new Particle(this);
for(int split_k = 0; split_k < partition->K; split_k++){
if(partition->cluster_config[split_k] > 2){
get_leftcenterright(A_or_B, left_center_right, split_k);
// now try to remove just the left-tail
left_conncomp.clear();
left_conncomp.push_back(std::vector<int>(1, left_center_right[0][0]));
for(int i = 1; i < (int)left_center_right[0].size(); i++){
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Find_TailSplit(A_or_B, 0, i, split_k, left_center_right, left_conncomp, indices, ns);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "left TailSplit";
}
// The merge part only merges one of the splits to its best neighboring cluster.
if(partition->K > 1){
left_k_star = get_tail_jstar(A_or_B, split_k, left_conncomp);
for(int j = 0; j < (int)left_conncomp.size(); j++){
if(left_k_star[j] != -1){
if(j == 0){
to_be_merged = split_k;
} else {
to_be_merged = partition->K + j - 1; // because indices contains left_conncomp first
}
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns);
tmp_candidate->Partition_Merge(A_or_B, to_be_merged, left_k_star[j]);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "left TailSplitMerge";
}
}
}
}
for(int c = 0; c < (int)indices.size(); c++){
indices[c].clear();
}
indices.clear();
ns.clear();
} // end left-tail
// now try to remove just the right tail
right_conncomp.clear();
right_conncomp.push_back(std::vector<int>(1, left_center_right[2][0]));
for(int i = 1; i < (int)left_center_right[2].size(); i++){
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Find_TailSplit(A_or_B, 2, i, split_k, left_center_right, right_conncomp, indices, ns);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "right TailSplit";
}
if(partition->K > 1){
right_k_star = get_tail_jstar(A_or_B, split_k, right_conncomp);
for(int j = 0; j < (int)right_conncomp.size(); j++){
if(right_k_star[j] != -1){
if(j == 0){
to_be_merged = split_k;
} else {
to_be_merged = partition->K + j - 1; // because indices contains right_conncomp first
}
delete tmp_candidate;
tmp_candidate = new Particle(this);
tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns);
tmp_candidate->Partition_Merge(A_or_B, to_be_merged, right_k_star[j]);
tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
if(tmp_objective > *pointer_to_maxobjective){
delete max_candidate;
max_candidate = new Particle(tmp_candidate);
*pointer_to_maxobjective = tmp_objective;
*pt_maxstr = "right TailSplitMerge";
}
}
}
}
}
}
}
delete tmp_candidate;
return;
}
void Particle::Update_Particle(int current_l, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, bool restricted){
if(A_or_B_first == 1.0){
if(sampleA){
Update_Partition(1, current_l, Particle_Set, w, lambda, xi, restricted);
}
if(sampleB){
Update_Partition(0, current_l, Particle_Set, w, lambda, xi, restricted);
}
} else if(A_or_B_first == 0.0){
if(sampleB){
Update_Partition(0, current_l, Particle_Set, w, lambda, xi, restricted);
}
if(sampleA){
Update_Partition(1, current_l, Particle_Set, w, lambda, xi, restricted);
}
} else if(A_or_B_first == 0.5){
if(R::runif(0,1) < 0.5){
if(sampleA){
Update_Partition(1, current_l, Particle_Set, w, lambda, xi, restricted);
}
if(sampleB){
Update_Partition(0, current_l, Particle_Set, w, lambda, xi, restricted);
}
} else {
if(sampleB){
Update_Partition(0, current_l, Particle_Set, w, lambda, xi, restricted);
}
if(sampleA){
Update_Partition(1, current_l, Particle_Set, w, lambda, xi, restricted);
}
}
}
// alpha and beta are updated when we update the partition
}
double Particle::Total_Log_Post(){
double tot = 0;
if(opt_Y == 1){
tot += LikelihoodY();
} else if(opt_Y == 0){
tot += LikelihoodYAB();
} else if(opt_Y == 2){
tot += total_log_like();
}
// you need the prior for Palpha and Pbeta
tot += total_log_prior(partition_A);
tot += total_log_prior(partition_B);
return tot;
}
double Particle::LikelihoodYAB(){
int T = Y.n_cols;
double dof = nObs*T/2 + nObs; // sarebbe: + nObs/2 + nObs/2
vec Y_vec = zeros<vec>(nObs*T);
for(int i = 0; i < nObs; i++){
for(int t = 0; t < T; t++){
Y_vec(i*T + t) = Y(i,t) - alpha[i] - X(i,t)*beta[i];
}
}
double quad_form = as_scalar(Y_vec.t() * Y_vec);
double log_determ = 0.0;
for(int k = 0; k < partition_A->K; k++){
int cluster_size = partition_A->cluster_config[k];
if(cluster_size == 1){
double param = alpha[ partition_A->clusters[k][0] ];
quad_form += param*param/(a1/(1-rho)+a2);
log_determ += -log(a1/(1-rho)+a2);
} else {
mat O = ones<mat>(cluster_size, cluster_size);
vec param_vec = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
param_vec(i) = alpha[ partition_A->clusters[k][i] ];
}
mat A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_A->clusters[k], partition_A->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
mat D = diagmat(row_sums);
mat A_star_k = D - A_block_k;
mat M = rho * A_star_k;
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
mat Sigma0inv = (M/a1) - (M/a1) * O * (M/a1) / (sum(sum(M))/a1 + 1/a2);
double Sigma0inv_det = 0;
double Sigma0inv_det_sgn = 0;
log_det(Sigma0inv_det, Sigma0inv_det_sgn, Sigma0inv);
log_determ += Sigma0inv_det;
quad_form += as_scalar(param_vec.t() * Sigma0inv * param_vec);
}
}
for(int k = 0; k < partition_B->K; k++){
int cluster_size = partition_B->cluster_config[k];
if(cluster_size == 1){
double param = beta[ partition_B->clusters[k][0] ];
quad_form += param*param/(b1/(1-rho)+b2);
log_determ += -log(b1/(1-rho)+b2);
} else {
mat O = ones<mat>(cluster_size, cluster_size);
vec param_vec = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
param_vec(i) = beta[ partition_B->clusters[k][i] ];
}
mat A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_B->clusters[k], partition_B->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
mat D = diagmat(row_sums);
mat A_star_k = D - A_block_k;
mat M = rho * A_star_k;
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
mat Sigma0inv = (M/b1) - (M/b1) * O * (M/b1) / (sum(sum(M))/b1 + 1/b2);
double Sigma0inv_det = 0;
double Sigma0inv_det_sgn = 0;
log_det(Sigma0inv_det, Sigma0inv_det_sgn, Sigma0inv);
log_determ += Sigma0inv_det;
quad_form += as_scalar(param_vec.t() * Sigma0inv * param_vec);
}
}
double numerator = lgamma(alpha_sigma + dof) + alpha_sigma * log(beta_sigma);
double denominator = lgamma(alpha_sigma) + (alpha_sigma + dof) * log(beta_sigma + quad_form/2);
double log_likeYAB = 0.5 * log_determ + numerator - denominator;
return log_likeYAB;
}
double Particle::LikelihoodY(){
int T = Y.n_cols;
mat E = eye<mat>(nObs,nObs);
mat O_k, A_block_k, Omega_k, D, M;
mat Omega_a = zeros<mat>(nObs,nObs);
mat Omega_b = zeros<mat>(nObs,nObs);
// I am updating Omega_a (the inverse of the covariance matrix of alpha) cluster-wise
for(int k = 0; k < partition_A->K; k++){
int cluster_size = partition_A->cluster_config[k];
if(cluster_size == 1){
Omega_a(partition_A->clusters[k][0], partition_A->clusters[k][0]) = 1/(a1/(1-rho)+a2);
} else {
O_k = ones<mat>(cluster_size,cluster_size);
// Creating M: the precision matrix of the CAR model
A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_A->clusters[k], partition_A->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
D = diagmat(row_sums);
M = rho * (D - A_block_k);
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// This is the Woodbury matrix identity for inversion
// Omega_k = (M/a1) - (M/a1) * O_k * (M/a1) / (sum(sum(M))/a1 + 1/a2);
// Woodbury matrix identity + remember that M*1 = (1-rho)*1
Omega_k = (M/a1) - ((1-rho)/a1)*((1-rho)/a1) / ( cluster_size*(1-rho)/a1 + 1/a2) * O_k;
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
Omega_a(partition_A->clusters[k][i], partition_A->clusters[k][j]) = Omega_k(i,j);
}
}
}
}
// I am updating Omega_b (the inverse of the covariance matrix of beta) cluster-wise
for(int k = 0; k < partition_B->K; k++){
int cluster_size = partition_B->cluster_config[k];
if(cluster_size == 1){
Omega_b(partition_B->clusters[k][0], partition_B->clusters[k][0]) = 1/(b1/(1-rho)+b2);
} else {
O_k = ones<mat>(cluster_size,cluster_size);
// Creating M: the precision matrix of the CAR model
A_block_k = Submatrix(A_block, cluster_size, cluster_size, partition_B->clusters[k], partition_B->clusters[k]);
vec row_sums = zeros<vec>(cluster_size);
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
row_sums(i) += A_block_k(i,j);
}
}
D = diagmat(row_sums);
M = rho * (D - A_block_k);
for(int i = 0; i < cluster_size; i++){
M(i,i) += 1 - rho;
}
// This is the Woodbury matrix identity for inversion
// Omega_k = (M/b1) - (M/b1) * O_k * (M/b1) / (sum(sum(M))/b1 + 1/b2);
// Woodbury matrix identity + remember that M*1 = (1-rho)*1
Omega_k = (M/b1) - ((1-rho)/b1)*((1-rho)/b1) / ( cluster_size*(1-rho)/b1 + 1/b2) * O_k;
for(int i = 0; i < cluster_size; i++){
for(int j = 0; j < cluster_size; j++){
Omega_b(partition_B->clusters[k][i], partition_B->clusters[k][j]) = Omega_k(i,j);
}
}
}
}
arma::mat sumX = diagmat(sum(X,1));
arma::mat sumX2 = diagmat(sum(X%X,1));
mat P, P11, P12, P21, P22;
if(opt_method == 1){
P11 = *I11;
P12 = *I12;
P21 = *I21;
P22 = *I22;
P = arma::join_cols(arma::join_rows(P11, P12),arma::join_rows(P21, P22));
} else {
P = block_inverse_ret(E*T + Omega_a, sumX, sumX, sumX2+Omega_b, &P11, &P12, &P21, &P22);
}
arma::vec xty1 = sum(Y,1);
arma::vec xty2 = sum(X%Y,1);
arma::vec XtY = arma::join_cols(xty1,xty2);
double quad_form = accu(Y%Y);
quad_form += - as_scalar(XtY.t() * P * XtY);
double Omega_log_det = 0;
double Omega_log_det_sgn = 0;
// Using Sylvester's + Woodbury determinant theorem: det(I + X Sigma Xt)^-1 = det(I - X P Xt) = det(I - P XtX) - so we need to multiply for 0.5
arma::mat Sigma_det = arma::join_cols(arma::join_rows(E - (T*P11 + P12*sumX), -(P11*sumX+P12*sumX2)),arma::join_rows(-(T*P21 + P22*sumX), E-(P21*sumX+P22*sumX2)));
arma::log_det(Omega_log_det, Omega_log_det_sgn, Sigma_det);
// potentially you can try the formula for block matrices
// Omega_log_det = block_log_det(E - (T*P11 + P12*sumX), -(P11*sumX+P12*sumX2)), -(T*P21 + P22*sumX), E-(P21*sumX+P22*sumX2));
double numerator = lgamma(alpha_sigma + ( (double) nObs * T/2)) + alpha_sigma * log(beta_sigma);
double denominator = lgamma(alpha_sigma) + (alpha_sigma + ( (double)nObs * T/2)) * log(beta_sigma + quad_form/2);
return 0.5 * Omega_log_det + numerator - denominator;
}
double Particle::total_log_like(){
int T = Y.n_cols;
double n = nObs;
double log_like;
double log_det = 0.0;
double quad_form = accu(Y%Y);
for(int k = 0; k < partition_A->K; k++){
log_det += partition_A->log_det_Omegay[k];
quad_form += partition_A->quad_forms[k];
}
for(int k = 0; k < partition_B->K; k++){
log_det += partition_B->log_det_Omegay[k];
quad_form += partition_B->quad_forms[k];
}
log_like = lgamma(alpha_sigma + ( n * T/2)) + alpha_sigma * log(beta_sigma); // numerator
log_like += - lgamma(alpha_sigma) - (alpha_sigma + ( n * T/2)) * log(beta_sigma + quad_form/2); // denominator
log_like += 0.5 * log_det;
return log_like;
}
void Particle::Print_Particle_Short(){
cout << "Partition A: " << endl;
partition_A->Print_Partition_Short();
cout << "Partition B: " << endl;
partition_B->Print_Partition_Short();
// cout << "alpha: "<< endl;
// for(int i = 0; i < nObs; i++){
// cout << alpha[i] << " ";
// }
// cout << endl;
// cout << "beta: "<< endl;
// for(int i = 0; i < nObs; i++){
// cout << beta[i] << " ";
// }
// cout << endl;
//cout << "hyper-parameters: " << sigma << " " << tau_A << " " << tau_B << endl;
}
void Particle::Print_Particle(){
cout << "Partition A: " << endl;
partition_A->Print_Partition();
cout << "Partition B: " << endl;
partition_B->Print_Partition();
if(opt_Y == 1){
cout << LikelihoodY() << endl;
} else if(opt_Y == 0){
cout << LikelihoodYAB() << endl;
} else if(opt_Y == 2){
cout << total_log_like() << endl;
}
cout << "Log-posterior: " << Total_Log_Post() << endl;
// cout << "alpha: "<< endl;
// for(int i = 0; i < nObs; i++){
// cout << alpha[i] << " ";
// }
// cout << endl;
// cout << "beta: "<< endl;
// for(int i = 0; i < nObs; i++){
// cout << beta[i] << " ";
// }
// cout << endl;
}
void Particle::Print_Particle_ToFile(string file){
partition_A->Print_Partition_ToFile(file);
partition_B->Print_Partition_ToFile(file);
return;
}
void Particle::Find_Splits_nonconnected(bool A_or_B, int cluster_id, int n_cl, int* component_i, int* component_not_i, int **index1_ptr, int **index2_ptr, int &n1, int &n2){
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
arma::mat A_block_cluster = Submatrix(A_block, n_cl, n_cl, component_i, component_i);
arma::mat param_sim = zeros<mat>(n_cl, n_cl);
arma::vec param_cluster(n_cl); // an armadillo vector holding the beta-hats
for(int i = 0; i < n_cl; i++){
param_cluster(i) = parameter[component_i[i]];
}
double beta_hat_var = arma::var(param_cluster); // variance of the beta_hats within the cluster
// populate the param_similarity matrix
double error = 0.0;
std::default_random_engine generator;
std::normal_distribution<double> distribution(0.0,beta_hat_var);
for(int i = 0; i < n_cl - 1; i++){
for(int j = i; j < n_cl; j++){
// error = distribution(generator);
param_sim(i,j) = exp(-1 * (param_cluster(i) - param_cluster(j) + error) * (param_cluster(i) - param_cluster(j) + error)/(2 * beta_hat_var));
param_sim(j,i) = exp(-1 * (param_cluster(i) - param_cluster(j) + error) * (param_cluster(i) - param_cluster(j) + error)/(2 * beta_hat_var));
}
}
arma::mat diag_ncl(n_cl,n_cl,fill::eye);
arma::mat W_beta_cl = diag_ncl + param_sim % A_block_cluster;
arma::mat Dinv_sqrt = arma::diagmat(1/sqrt(arma::sum(W_beta_cl, 1)));
arma::mat L = diag_ncl - Dinv_sqrt * W_beta_cl * Dinv_sqrt;
arma::vec eigval; // the smallest eigenvalues are the first two
arma::mat eigvec;
eig_sym(eigval, eigvec, L);
mat U = eigvec.cols(0,1);
U = arma::diagmat(1/sqrt(arma::sum(arma::square(U), 1))) * U;
arma::mat means;
// kmeans(means, U.t(), 2, random_subset, 10, false);
bool status = arma::kmeans(means, U.t(), 2, random_subset, 10, false);
if(status == false)
cout << "clustering failed" << endl;
int * membership = which_is_nearest_k(means, U.t());
(*index1_ptr) = new int[n_cl];
(*index2_ptr) = new int[partition->cluster_config[cluster_id]];
n1 = 0;
n2 = 0;
for(int i = 0; i < n_cl; i++){
if(membership[i] == 0){
(*index1_ptr)[n1] = component_i[i];
(n1)++;
}
else {
(*index2_ptr)[n2] = component_i[i];
(n2)++;
}
}
delete[] membership;
for(int i = 0; i < (partition->cluster_config[cluster_id]-n_cl); i++){
(*index2_ptr)[n2] = component_not_i[i];
(n2)++;
}
Partition_Split(A_or_B, cluster_id, *index1_ptr, *index2_ptr, n1, n2);
}
void Particle::Find_Splits_nonspatial(bool A_or_B, int cluster_id, int **index1_ptr, int **index2_ptr, int &n1, int &n2){
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
int n_cl = partition->cluster_config[cluster_id];
arma::vec param_cluster(n_cl); // an armadillo vector holding the beta-hats
for(int i = 0; i < n_cl; i++){
param_cluster(i) = parameter[partition->clusters[cluster_id][i]];
}
arma::mat means;
bool status = arma::kmeans(means, param_cluster.t(), 2, random_subset, 10, false);
if(status == false)
cout << "clustering failed" << endl;
int * membership = which_is_nearest_k(means, param_cluster.t());
(*index1_ptr) = new int[n_cl];
(*index2_ptr) = new int[n_cl];
n1 = 0;
n2 = 0;
for(int i = 0; i < n_cl; i++){
if(membership[i] == 0){
(*index1_ptr)[n1] = partition->clusters[cluster_id][i];
(n1)++;
}
else {
(*index2_ptr)[n2] = partition->clusters[cluster_id][i];
(n2)++;
}
}
delete[] membership;
Partition_Split(A_or_B, cluster_id, *index1_ptr, *index2_ptr, n1, n2);
}
bool Particle::Find_K_SpectralSplits(bool A_or_B, int split_k, int num_splits, std::vector<std::vector<int> >& indices, std::vector<int>& ns, bool use_mle){
// indices now contains numbers between 0 and nObs-1
if(num_splits <= 1){
return false;
} else {
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
if(use_mle){
parameter = alpha_mle;
}
} else {
partition = partition_B;
parameter = beta;
if(use_mle){
parameter = beta_mle;
}
}
// int SCiter = 2;
int n_cl = partition->cluster_config[split_k];
/* populate the similarity_matrixilarity matrix */
arma::vec param_cluster(n_cl);
for(int i = 0; i < n_cl; i++){
param_cluster(i) = parameter[partition->clusters[split_k][i]];
}
double param_var = arma::var(param_cluster);
arma::mat similarity_matrix = zeros<mat>(n_cl, n_cl);
/* // for randomness, not used for now
std::default_random_engine generator;
std::normal_distribution<double> distribution(0.0,param_var);
*/
double error = 0.0; // for randomness, not used for now
for(int i = 0; i < n_cl - 1; i++){
for(int j = i; j < n_cl; j++){
// error = distribution(generator); // for randomness, not used for now
similarity_matrix(i,j) = exp(-1 * (param_cluster(i) - param_cluster(j) + error) * (param_cluster(i) - param_cluster(j) + error)/(2 * param_var));
similarity_matrix(j,i) = exp(-1 * (param_cluster(i) - param_cluster(j) + error) * (param_cluster(i) - param_cluster(j) + error)/(2 * param_var));
}
}
/* Here goes spectral clustering */
arma::mat A_block_cluster = Submatrix(A_block, n_cl, n_cl, partition->clusters[split_k], partition->clusters[split_k]);
arma::mat diag_n(n_cl,n_cl,fill::eye);
arma::mat W_beta_cl = diag_n + similarity_matrix % A_block_cluster;
arma::mat Dinv_sqrt = arma::diagmat(1/sqrt(arma::sum(W_beta_cl, 1)));
arma::mat L = diag_n - Dinv_sqrt * W_beta_cl * Dinv_sqrt;
arma::vec eigval; // the smallest eigenvalues are the first two
arma::mat eigvec;
eig_sym(eigval, eigvec, L);
mat U = eigvec.cols(0,num_splits-1);
U = arma::diagmat(1/sqrt(arma::sum(arma::square(U), 1))) * U;
arma::mat means;
indices.clear();
indices.resize(num_splits);
ns.clear();
ns.resize(num_splits);
double min_score; // actually I don't think I'll use it
int * membership;
bool status = false;
int loop_check = 0;
int kmeans_rep_tmp = kmeans_rep;
if(num_splits > 3){
kmeans_rep_tmp = (num_splits - 2)*kmeans_rep;
}
while((!status) && (loop_check < 10)){
status = kmeans_repeat(means, U, num_splits, kmeans_rep_tmp, min_score);
if(status == false){
cout << "clustering failed" << endl;
// go directly to next iteration: i.e. do kmeans again
}
loop_check++;
}
// membership is long n_cl and has elements between 0 and num_splits-1
membership = which_is_nearest_k(means, U.t());
for(int j = 0; j<num_splits; j++){
ns[j] = 0;
}
// CHANGED: now indices has the actual indices from 0 to nObs-1
// before indices had elements between 0 and n_cl-1
for(int i = 0; i < n_cl; i++){
indices[membership[i]].push_back( partition->clusters[split_k][i] );
(ns[membership[i]])++;
}
int *components;
int *count;
for(int j = 0; j < num_splits; j++){
mat A_cluster = Submatrix(A_block, ns[j], ns[j], indices[j], indices[j]);
components = new int[ ns[j] ];
count = new int;
Connected_Components(A_cluster, ns[j],components,count);
if((*count)!=1){
// instead of iterating let's change indices:
// save the connected components of indices[j] as a vector
std::vector<std::vector<int> > new_indices;
new_indices.resize(*count);
for(int i = 0; i < ns[j]; i++){
new_indices[ components[i] ].push_back(indices[j][i]);
}
// we can eliminate the current element of indices[j] and ns[j]
indices[j].clear();
// now we update the previous element indices[j] and add new ones
for(int c = 0; c < (*count); c++){
if(c == 0){
indices[j] = new_indices[0];
ns[j] = new_indices[0].size();
} else {
indices.push_back(new_indices[c]);
ns.push_back(new_indices[c].size());
}
}
}
delete[] components;
delete count;
}
delete[] membership;
Partition_KSplit(A_or_B, split_k, indices, ns);
return true;
}
}
bool Particle::Find_KM_Splits(bool A_or_B, int split_k, int num_splits, std::vector<std::vector<int> >& indices, std::vector<int>& ns, bool use_mle){
// indices now contains numbers between 0 and nObs-1
if(num_splits <= 1){
return false;
} else {
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
if(use_mle){
parameter = alpha_mle;
}
} else {
partition = partition_B;
parameter = beta;
if(use_mle){
parameter = beta_mle;
}
}
// int SCiter = 2;
int n_cl = partition->cluster_config[split_k];
arma::mat U = arma::zeros<mat>(n_cl, 1); // holds the data passed to k-means
U.set_size(n_cl, 1);
for(int i = 0; i < n_cl; i++){
U(i,0) = parameter[partition->clusters[split_k][i]];
}
arma::mat means;
indices.clear();
indices.resize(num_splits);
ns.clear();
ns.resize(num_splits);
double min_score;
int * membership;
bool status = false;
int loop_check = 0;
while(!status){
// status = arma::kmeans(means, U.t(), num_splits, random_subset, 10, false);
status = kmeans_repeat(means, U, num_splits, kmeans_rep, min_score);
if(status == false){
cout << "clustering failed" << endl;
// go directly to next iteration: i.e. do kmeans again
}
loop_check++;
if(loop_check > 3){
return -1;
}
}
// membership is long n_cl and has elements between 0 and num_splits-1
membership = which_is_nearest_k(means, U.t());
for(int j = 0; j<num_splits; j++){
ns[j] = 0;
}
// indices has the actual indices from 0 to nObs-1
for(int i = 0; i < n_cl; i++){
indices[membership[i]].push_back( partition->clusters[split_k][i] );
(ns[membership[i]])++;
}
int *components;
int *count;
for(int j = 0; j < num_splits; j++){
mat A_cluster = Submatrix(A_block, ns[j], ns[j], indices[j], indices[j]);
components = new int[ ns[j] ];
count = new int;
Connected_Components(A_cluster, ns[j],components,count);
if((*count)!=1){
// instead of iterating let's change indices:
// save the connected components of indices[j] as a vector
std::vector<std::vector<int> > new_indices;
new_indices.resize(*count);
for(int i = 0; i < ns[j]; i++){
new_indices[ components[i] ].push_back(indices[j][i]);
}
// we can eliminate the current element of indices[j] and ns[j]
indices[j].clear();
// now we update the previous element indices[j] and add new ones
for(int c = 0; c < (*count); c++){
if(c == 0){
indices[j] = new_indices[0];
ns[j] = new_indices[0].size();
} else {
indices.push_back(new_indices[c]);
ns.push_back(new_indices[c].size());
}
}
}
delete[] components;
delete count;
}
delete[] membership;
Partition_KSplit(A_or_B, split_k, indices, ns);
return true;
}
}
void Particle::Find_TailSplit(bool A_or_B, int left0right2, int i, int split_k, std::vector<std::vector<int> > left_center_right, std::vector<std::vector<int> >& tail_conncomp, std::vector<std::vector<int> >& indices, std::vector<int>& ns){
// adds element i to left_tail and finds its connected component (tail_conncomp), then splits
std::vector<int> remain; // contains all of the indices that are not split
std::vector<std::vector<int> > remain_conncomp;
for(int ii = i+1; ii < (int)left_center_right[left0right2].size(); ii++){
remain.push_back(left_center_right[left0right2][ii]);
}
for(int ii = 0; ii < (int)left_center_right[1].size(); ii++){
remain.push_back(left_center_right[1][ii]);
}
for(int ii = 0; ii < (int)left_center_right[2-left0right2].size(); ii++){
remain.push_back(left_center_right[2-left0right2][ii]);
}
remain_conncomp = Alternative_Connected_Components(remain);
Alternative_Connected_Components(left_center_right[left0right2][i], tail_conncomp);
// prepare indices for KSplit
indices.clear();
ns.clear();
for(int cc = 0; cc < (int)tail_conncomp.size(); cc++){
indices.push_back(tail_conncomp[cc]);
ns.push_back(tail_conncomp[cc].size());
}
for(int cc = 0; cc < (int)remain_conncomp.size(); cc++){
indices.push_back(remain_conncomp[cc]);
ns.push_back(remain_conncomp[cc].size());
}
Partition_KSplit(A_or_B, split_k, indices, ns);
return;
}
void Particle::Initial_K_Splits(int num_splits_A, int num_splits_B, bool use_mle){
std::vector<std::vector<int> > indices;
std::vector<int> ns;
if(num_splits_A > 1)
Find_K_SpectralSplits(1, 0, num_splits_A, indices, ns, use_mle);
if(num_splits_B > 1)
Find_K_SpectralSplits(0, 0, num_splits_B, indices, ns, use_mle);
return;
}
void Particle::Initial_KM_Splits(int num_splits_A, int num_splits_B, bool use_mle){
std::vector<std::vector<int> > indices;
std::vector<int> ns;
if(num_splits_A > 1)
Find_KM_Splits(1, 0, num_splits_A, indices, ns, use_mle);
if(num_splits_B > 1)
Find_KM_Splits(0, 0, num_splits_B, indices, ns, use_mle);
return;
}
double Particle::param_bar(bool A_or_B, int k){
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
arma::vec param_cl(partition->cluster_config[k]);
for(int i = 0; i < partition->cluster_config[k]; i++){
param_cl(i) = parameter[ partition->clusters[k][i] ];
}
return arma::mean(param_cl);
}
void Particle::get_leftcenterright(bool A_or_B, std::vector<std::vector<int> >& left_center_right, int split_k){
LPPartition partition;
double* parameter;
if(A_or_B){
partition = partition_A;
parameter = alpha;
} else {
partition = partition_B;
parameter = beta;
}
int n_k = partition->cluster_config[split_k];
int size_tail = ceil(n_k*split_frac);
arma::vec param_cluster(1);
arma::uvec param_indices(1);
param_cluster.set_size(n_k); // holds the alpha_hat's within the cluster
for(int i = 0; i < n_k; i++){
param_cluster(i) = parameter[partition->clusters[split_k][i]];
}
param_indices = arma::sort_index(param_cluster, "ascend"); // sort in ascending order
left_center_right.clear();
left_center_right.resize(3);
for(int i = 0; i < size_tail; i++){
left_center_right[0].push_back(partition->clusters[split_k][param_indices(i)]);
left_center_right[2].push_back(partition->clusters[split_k][param_indices(n_k-1 - i)]);
}
for(int i = size_tail; i < n_k-size_tail; i++){
left_center_right[1].push_back(partition->clusters[split_k][param_indices(i)]);
}
return;
}
// void Particle::Partition_K_Splits(bool A_or_B, int cluster_id, int num_splits){
// std::vector<std::vector<int> > indices;
// std::vector<int> ns;
// Find_K_SpectralSplits(A_or_B, cluster_id, num_splits, indices, ns);
// // bool split = Find_K_SpectralSplits(A_or_B, num_splits, cluster_id, indices, ns);
// // if(split){
// // cout << "Partition_K_Splits: " << ns[0] << endl;
// // }
// return;
// }
// void Particle::Spectral_SplitMerge_moves(bool A_or_B, double *pointer_to_maxobjective, int current_l, LPParticle& tmp_candidate, LPParticle& max_candidate, std::vector<LPParticle> Particle_Set, std::vector<double> w, double lambda, double xi, string *pt_maxstr){
// LPPartition partition;
// double* parameter;
// if(A_or_B){
// partition = partition_A;
// parameter = alpha;
// } else {
// partition = partition_B;
// parameter = beta;
// }
// arma::mat tmp_A;
// double tmp_objective = 0.0;
// std::vector<std::vector<int> > indices;
// std::vector<int> ns;
// for(int split_k = 0; split_k < partition->K; split_k++){
// if(partition->cluster_config[split_k] > 2){
// int num_splits = 2;
// delete tmp_candidate;
// tmp_candidate = new Particle(this);
// tmp_objective = 0.0;
// // now just try splitting
// tmp_candidate->Find_K_SpectralSplits(A_or_B, split_k, num_splits, indices, ns);
// tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
// // index1, index2 are the same as indices but they are pointers.
// // int *index1, *index2;
// // index1 = new int[ns[0]];
// // index2 = new int[ns[1]];
// // for(int i = 0; i < ns[0]; i++){
// // index1[i] = indices[0][i];
// // }
// // for(int i = 0; i < ns[1]; i++){
// // index2[i] = indices[1][i];
// // }
// if(tmp_objective > *pointer_to_maxobjective){
// delete max_candidate;
// max_candidate = new Particle(tmp_candidate);
// *pointer_to_maxobjective = tmp_objective;
// *pt_maxstr = "Split";
// }
// // now do the split and merge part
// if(partition->K>1){
// // we find the clusters adjacent to the new two clusters, adj_clusters1 and adj_clusters2
// arma::vec param_cluster1_vec(ns[0]);
// arma::vec param_cluster2_vec(ns[1]);
// for(int i = 0; i < ns[0]; i++){
// param_cluster1_vec(i) = parameter[ indices[0][i] ];
// }
// for(int i = 0; i < ns[1]; i++){
// param_cluster2_vec(i) = parameter[ indices[1][i] ];
// }
// double beta_bar1 = arma::mean(param_cluster1_vec);
// double beta_bar2 = arma::mean(param_cluster2_vec);
// std::vector<std::vector<int> > adj_clusters;
// adj_clusters.resize(num_splits);
// for(int kk = 0; kk < partition->K; kk++){
// if(kk != split_k){
// for(int j = 0; j < num_splits; j++){
// tmp_A = Submatrix(A_block, ns[j], partition->cluster_config[kk], indices[j], partition->clusters[kk]);
// if(any(vectorise(tmp_A == 1.0))){
// adj_clusters[j].push_back(kk);
// }
// }
// }
// }
// int jstar1;
// int jstar2;
// // keep indices[1] by itself (and labelled cluster K) and merge indices[0] into closest existing cluster that is adjacent to it and has similar average beta-hat (requires identifying k_star_1)
// if(adj_clusters[0].size() > 0) {
// // we find jstar1: the cluster adjacent to newcluster1 and closest in mean
// double tmp_min = abs(param_bar(A_or_B, adj_clusters[0][0])-beta_bar1);
// jstar1 = adj_clusters[0][0];
// double tmp;
// for(int ii = 1; ii < adj_clusters[0].size(); ii++){
// tmp = abs(param_bar(A_or_B, adj_clusters[0][ii])-beta_bar1);
// if(tmp < tmp_min){
// jstar1 = adj_clusters[0][ii];
// }
// }
// // now we know we should try to merge indices[0] with jstar1
// delete tmp_candidate;
// tmp_candidate = new Particle(this);
// tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns); // now cluster1 is still split_k, cluster2 is K
// // tmp_candidate->Partition_Split(A_or_B, split_k, indices[0], indices[1], ns[0], ns[1]); // now cluster1 is still split_k, cluster2 is K
// tmp_candidate->Partition_Merge(A_or_B, split_k, jstar1);
// tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
// if(tmp_objective > *pointer_to_maxobjective){
// delete max_candidate;
// max_candidate = new Particle(tmp_candidate);
// *pointer_to_maxobjective = tmp_objective;
// *pt_maxstr = "SplitMerge1";
// }
// }
// // keep indices[0] by itself (and labelled cluster k) and merge indices[1] into the closest existing cluster that is adjacent to it and has similar average beta-hat (requires identify k_star_2)
// if(adj_clusters[1].size() > 0) {
// // we find jstar2: the cluster adjacent to newcluster2 and closest in mean
// double tmp_min = abs(param_bar(A_or_B, adj_clusters[1][0])-beta_bar2);
// jstar2 = adj_clusters[1][0];
// double tmp;
// for(int ii = 1; ii < adj_clusters[1].size(); ii++){
// tmp = abs(param_bar(A_or_B, adj_clusters[1][ii])-beta_bar2);
// if(tmp < tmp_min){
// jstar2 = adj_clusters[1][ii];
// }
// }
// // now we know we should try to merge indices[1] with jstar2
// delete tmp_candidate;
// tmp_candidate = new Particle(this);
// tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns);
// // tmp_candidate->Partition_Split(A_or_B, split_k, indices[0], indices[1], ns[0], ns[1]); // now cluster1 is still split_k, cluster2 is K
// tmp_candidate->Partition_Merge(A_or_B, partition->K,jstar2);
// tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
// if(tmp_objective > *pointer_to_maxobjective){
// delete max_candidate;
// max_candidate = new Particle(tmp_candidate);
// *pointer_to_maxobjective = tmp_objective;
// *pt_maxstr = "SplitMerge2";
// }
// }
// // merge both indices[0] and indices[1] into existing clusters (so long as they're not merging into the same one!!)
// if(adj_clusters[0].size() > 0 && adj_clusters[1].size() > 0){
// if(jstar1 != jstar2){
// delete tmp_candidate;
// tmp_candidate = new Particle(this);
// tmp_candidate->Partition_KSplit(A_or_B, split_k, indices, ns);
// // tmp_candidate->Partition_Split(A_or_B, split_k, indices[0], indices[1], ns[0], ns[1]); // now cluster1 is still split_k, cluster2 is K
// // the order matters!
// tmp_candidate->Partition_Merge(A_or_B, partition->K,jstar2);
// tmp_candidate->Partition_Merge(A_or_B, split_k,jstar1);
// tmp_objective = w[current_l]*tmp_candidate->Total_Log_Post() + lambda * Entropy(current_l, tmp_candidate, Particle_Set, w) + xi * VI_Avg(current_l, tmp_candidate, Particle_Set);
// if(tmp_objective > *pointer_to_maxobjective){
// delete max_candidate;
// max_candidate = new Particle(tmp_candidate);
// *pointer_to_maxobjective = tmp_objective;
// *pt_maxstr = "SplitMerge3";
// }
// }
// }
// // done with split and merge
// }
// }
// }
// return;
// }
// void Particle::Find_SpectralSplits(bool A_or_B, int cluster_id, int **index1_ptr, int **index2_ptr, int &n1, int &n2){
// LPPartition partition;
// double* parameter;
// if(A_or_B){
// partition = partition_A;
// parameter = alpha;
// } else {
// partition = partition_B;
// parameter = beta;
// }
// int n_cl = partition->cluster_config[cluster_id];
// /* populate the similarity_matrixilarity matrix */
// arma::vec param_cluster(n_cl);
// arma::mat A_block_cluster = Submatrix(A_block, n_cl, n_cl, partition->clusters[cluster_id], partition->clusters[cluster_id]);
// for(int i = 0; i < n_cl; i++){
// param_cluster(i) = parameter[partition->clusters[cluster_id][i]];
// }
// double param_var = arma::var(param_cluster); // variance of the parameter within the cluster
// arma::mat similarity_matrix = zeros<mat>(n_cl, n_cl);
// /* // for randomness, not used for now
// std::default_random_engine generator;
// std::normal_distribution<double> distribution(0.0,param_var);
// */
// double error = 0.0; // for randomness, not used for now
// for(int i = 0; i < n_cl - 1; i++){
// for(int j = i; j < n_cl; j++){
// // error = distribution(generator); // for randomness, not used for now
// similarity_matrix(i,j) = exp(-1 * (param_cluster(i) - param_cluster(j) + error) * (param_cluster(i) - param_cluster(j) + error)/(2 * param_var));
// similarity_matrix(j,i) = exp(-1 * (param_cluster(i) - param_cluster(j) + error) * (param_cluster(i) - param_cluster(j) + error)/(2 * param_var));
// }
// }
// /* Here goes spectral clustering */
// arma::mat eye_ncl(n_cl,n_cl,fill::eye);
// arma::mat W_param_cl = eye_ncl + similarity_matrix % A_block_cluster;
// arma::mat Dinv_sqrt = arma::diagmat(1/sqrt(arma::sum(W_param_cl, 1)));
// arma::mat L = eye_ncl - Dinv_sqrt * W_param_cl * Dinv_sqrt;
// arma::vec eigval; // the smallest eigenvalues are the first two
// arma::mat eigvec;
// eig_sym(eigval, eigvec, L);
// mat U = eigvec.cols(0,1);
// U = arma::diagmat(1/sqrt(arma::sum(arma::square(U), 1))) * U;
// arma::mat means;
// bool status = arma::kmeans(means, U.t(), 2, random_subset, 10, false);
// if(status == false){
// // we should instead send an exception.. For now we are only printing a message
// cout << "clustering failed" << endl;
// } else {
// int * membership = which_is_nearest_k(means, U.t());
// (*index1_ptr) = new int[n_cl];
// (*index2_ptr) = new int[n_cl];
// n1 = 0;
// n2 = 0;
// for(int i = 0; i < n_cl; i++){
// if(membership[i] == 0){
// (*index1_ptr)[n1] = partition->clusters[cluster_id][i];
// (n1)++;
// }
// else {
// (*index2_ptr)[n2] = partition->clusters[cluster_id][i];
// (n2)++;
// }
// }
// delete[] membership;
// Partition_Split(A_or_B, cluster_id, *index1_ptr, *index2_ptr, n1, n2);
// }
// }
// int Particle::get_jstar(bool A_or_B, int k){
// LPPartition partition;
// double* parameter;
// if(A_or_B){
// partition = partition_A;
// parameter = alpha;
// } else {
// partition = partition_B;
// parameter = beta;
// }
// arma::vec beta_cluster_vec(partition->cluster_config[k]);
// for(int i = 0; i < partition->cluster_config[k]; i++){
// beta_cluster_vec(i) = parameter[ partition->clusters[k][i] ];
// }
// double beta_bar1 = arma::mean(beta_cluster_vec);
// int jstar;
// double tmp_min;
// double tmp;
// if(k != 0){
// tmp_min = abs(param_bar(A_or_B, 0)-beta_bar1);
// jstar = 0;
// }
// if(k != 1){
// tmp_min = abs(param_bar(A_or_B, 1)-beta_bar1);
// jstar = 1;
// }
// for(int kk = 0; kk < partition->K; kk++){
// if(kk != k){
// tmp = abs(param_bar(A_or_B, kk)-beta_bar1);
// if(tmp < tmp_min){
// jstar = kk;
// }
// }
// }
// return jstar;
// }
| [
"cecilia.balocchi@gmail.com"
] | cecilia.balocchi@gmail.com |
cc5c0ac76d4a3e004b8293700c9edab5e500ae6e | d1bae97cbf46068cc1e91a23aaac7340d4483265 | /SpaceGolfGame/SpaceGolfGame/Systems/VelocitySystem.cpp | b136226eee65276b897a389f0bf40c801eca174f | [] | no_license | jinsuoliu/SpaceGolfGame | 20cf02cc00f5f1cb6be442f95e0a2e1ab9927484 | 7cba5262c6495167aaccff9f198ec7f64f56d00d | refs/heads/master | 2020-08-06T21:51:53.985391 | 2018-06-09T12:23:51 | 2018-06-09T12:23:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 727 | cpp | #include "VelocitySystem.h"
#include "../Components/VelocityComponent.h"
#include "../Components/PositionComponent.h"
#include "../Components/MeshTransformCacheComponent.h"
VelocitySystem::VelocitySystem()
{
}
VelocitySystem::~VelocitySystem()
{
}
void VelocitySystem::update(entityx::EntityManager & entities, entityx::EventManager & events, entityx::TimeDelta dt)
{
entities.each<PositionComponent, VelocityComponent>([](entityx::Entity entity, PositionComponent& position, VelocityComponent& velocity) {
if (velocity.v.lengthSq() > 0) {
position.pos += velocity.v;
if (entity.component<MeshTransformCacheComponent>()) {
entity.component<MeshTransformCacheComponent>().get()->valid = false;
}
}
});
}
| [
"amer_zavlan@live.com"
] | amer_zavlan@live.com |
fbdd13b9124cc46ea5cebd3bf08c742806d17ea7 | 08b8cf38e1936e8cec27f84af0d3727321cec9c4 | /data/crawl/wget/hunk_201.cpp | d7527fed807577b5290b5ede3ac493baf9144c37 | [] | no_license | ccdxc/logSurvey | eaf28e9c2d6307140b17986d5c05106d1fd8e943 | 6b80226e1667c1e0760ab39160893ee19b0e9fb1 | refs/heads/master | 2022-01-07T21:31:55.446839 | 2018-04-21T14:12:43 | 2018-04-21T14:12:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 448 | cpp |
res = hash_table_get_pair (jar->chains, victim->domain,
&chain_key, NULL);
- assert (res != 0);
+
+ if (res == 0)
+ {
+ logprintf (LOG_VERBOSE, _("Unable to get cookie for %s\n"),
+ victim->domain);
+ }
if (!victim->next)
{
/* VICTIM was the only cookie in the chain. Destroy the
| [
"993273596@qq.com"
] | 993273596@qq.com |
a4a63b3f971d194b137f94b829ccacd90b4b32e2 | 877fff5bb313ccd23d1d01bf23b1e1f2b13bb85a | /app/src/main/cpp/dir7941/dir7942/dir8062/dir8063/dir8254/file12143.cpp | 6e49de0ef4ce34fb4b9cc9b04955ac99a0538aae | [] | no_license | tgeng/HugeProject | 829c3bdfb7cbaf57727c41263212d4a67e3eb93d | 4488d3b765e8827636ce5e878baacdf388710ef2 | refs/heads/master | 2022-08-21T16:58:54.161627 | 2020-05-28T01:54:03 | 2020-05-28T01:54:03 | 267,468,475 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 115 | cpp | #ifndef file12143
#error "macro file12143 must be defined"
#endif
static const char* file12143String = "file12143"; | [
"tgeng@google.com"
] | tgeng@google.com |
1e0e907a819e52558f74a012683eb74b3d6d6415 | 604e78eef855be5304b67887610b6067e7e1e71f | /PL0103_Cotejo_Prod_Matrices.cpp | a0ba7b36d5832e094d3753dc5defd199a0026271 | [] | no_license | ASAROVA/PL01_Pruebas_Cache | a8e8ed7bb1de2b6c7c7e8609b9503b180b5785da | 8ae29450efe166c751ab25177968696f5add3914 | refs/heads/master | 2022-12-20T10:17:31.668757 | 2020-09-23T04:49:40 | 2020-09-23T04:49:40 | 297,413,934 | 0 | 0 | null | null | null | null | WINDOWS-1250 | C++ | false | false | 6,799 | cpp | #include <iostream>
#include <ctime>
#include <vector>
#include <algorithm>
using namespace std;
#define SL cout<<endl
#define MIN 0
#define MAX 10
/// Generador de Numero Aleatorio /////////////////
#include <ctime>
int aleatorio (int minimo=0, int maximo=RAND_MAX )
{
static bool inicio = true;
if (inicio) { srand(time(NULL));
inicio = false; }
return minimo + rand()%(maximo-minimo);
}
/// ////////////////////////////////////////////*/
/// Matriz ///////////////////////////////////////
template<class T>
class matriz;
template<class T>
matriz<T> multibloque (const matriz<T>* A, const matriz<T>* B, int n=6)
{
if (!n) return (*A)*(*B);
int mm = B->nfilas;
int m = B->nfilas/2;
matriz<T> A1 ( A->nfilas,m);
matriz<T> A2 ( A->nfilas,mm-m);
for (int i=0;i<A->nfilas;i++)
{
int j=0;
for (;j<m;j++) A1[i][j] = (*A)[i][j];
for (;j<mm;j++) A2[i][j-m] = (*A)[i][j];
}
matriz<T> B1 ( m, B->ncolum);
matriz<T> B2 ( mm-m, B->ncolum);
for (int i=0;i<B->ncolum;i++)
{
int j=0;
for (;j<m;j++) B1[j][i] = (*B)[j][i];
for (;j<mm;j++) B2[j-m][i] = (*B)[j][i];
}
return multibloque(&A1,&B1,n-1) + multibloque(&A2,&B2,n-1);
}
template<class T>
class matriz : private vector<vector<T>>
{
//protected:
public:
int nfilas, ncolum;
typedef vector<vector<T>> vvt;
//public:
using vvt::push_back;
using vvt::operator[];
using vvt::begin;
using vvt::end;
matriz(): nfilas(0), ncolum(0), vvt() {}
matriz(initializer_list<vector<T>> L): vvt(L)
{
nfilas = L.size();
ncolum = L.begin()->size();
}
//virtual ~matriz() { vvt::~vvt(); }
matriz(int num_filas, int num_columnas, T val = T())
{
nfilas = num_filas;
ncolum = num_columnas;
this->resize(nfilas);
for (auto& i: *this)
{
i.resize(ncolum);
for(auto& ij: i) ij = val;
}
}
//matriz(vector<vector<T>>::iterator i,vector<vector<T>>::iterator j): vvt(i,j) {}
matriz<T> operator* (const matriz<T>& M) const
{
if(M.nfilas!=ncolum)
throw invalid_argument( "Dimensiones incompatibles" );
matriz<T> P(nfilas,M.ncolum,T());
for(int i=0; i<nfilas; i++)
{
for(int j=0; j<M.ncolum; j++)
for(int k=0; k<ncolum; k++)
P[i][j] += (*this)[i][k]*M[k][j];
}
return P;
}
/// /
matriz<T> mbloque (const matriz<T>& M) const
{
if(M.nfilas!=ncolum)
throw invalid_argument( "Dimensiones incompatibles" );
return multibloque(this, &M);
}
/// */
matriz<T> operator+ (const matriz<T>& M) const
{
if(M.nfilas!=nfilas or M.ncolum!=ncolum)
throw invalid_argument( "Dimensiones incompatibles" );
matriz<T> S(nfilas,ncolum);
for(int i=0; i<nfilas; i++)
for(int j=0; j<ncolum; j++)
S[i][j] += (*this)[i][j]+M[i][j];
return S;
}
void rellenar ( int minimo=MIN, int maximo=MAX )
{
for (auto& i: *this)
for(auto& ij: i) ij = aleatorio(minimo,maximo);
}
void imprimir()
{
for(int i=0; i<nfilas; i++)
{
for(int j=0; j<ncolum; j++)
cout << (*this)[i][j] << "\t";
SL;
}
}
template<class TT>
friend ostream& operator<<(ostream &, const matriz<TT> &);
//friend matriz<T> multibloque (matriz<T>*, matriz<T>*);
};
template<class T>
ostream &operator<<(ostream &os, matriz<T> const &M)
{
for(int i=0; i<M.nfilas; i++)
{
for(int j=0; j<M.ncolum; j++)
os << M[i][j] << "\t";
os << "\n";
}
return os;
}
typedef matriz<int> matrint;
typedef matriz<float> matflot;
/// ////////////////////////////////////////////*/
/// Functor que mide la demora de una función ////
template<typename T, typename TF>
class cronometro
{
TF f;
public:
cronometro() {}
void est_funcion(TF F) {f=F;}
double operator()(int alto, int ancho=0)
{
if(!ancho) ancho = alto;
matriz<T> M(alto,ancho);
M.rellenar();
matriz<T> N(alto,ancho);
N.rellenar();
clock_t t;
t = clock();
(M.*f)(N);
t = clock()-t;
return double(t)/double(CLOCKS_PER_SEC);
//return double(t);
}
};
/// ////////////////////////////////////////////*/
/// Tipo de funcion a medir y otras funciones ////
typedef int tipo;
typedef matriz<tipo>(matriz<tipo>::*funcion)(const matriz<tipo>&)const;
template <class T, class... TY>
void tabulador(vector<T> X, TY... Ys);
template <class T>
void interpolar(vector<T>& v,T inicio,T incremento,T fin);
/// ////////////////////////////////////////////*/
int main(void)
{
cout << "\n\t\t >> ASAROVA << \n\n";
/// Comparaciones //////////////////////////////
funcion f;
//vector<int> tamannos {100,200,400,800,1600};
//vector<int> tamannos {100,200,400};
vector<int> tamannos; interpolar(tamannos,100,100,1000);
cout << "Tabla de Demoras (seg)"; SL;SL;
cout << "Tamanno lado\t" << "Prod. Normal\t" << "Prod. Bloques\t"; SL;
vector<float> lapsos_ij, lapsos_ji;
lapsos_ij.resize(tamannos.size());
lapsos_ji.resize(tamannos.size());
cronometro<tipo,funcion> reloj;
reloj.est_funcion(matriz<tipo>::operator*);
transform(tamannos.begin(),tamannos.end(),lapsos_ij.begin(),reloj);
reloj.est_funcion(matriz<tipo>::mbloque);
transform(tamannos.begin(),tamannos.end(),lapsos_ji.begin(),reloj);
tabulador(tamannos,lapsos_ij,lapsos_ji);
SL;SL;
/// ////////////////////////////////////////////*/
//cout << demora<tipo,funcion>(f,400); SL;SL;
return 0;
}
/// Rutina de Tabulacion de vectores /////////////
template <class T, class... TY>
void tabulador(vector<T> X, TY... Ys)
{
int n = X.size();
for(int i=0;i<n;i++)
{
cout << X[i] << "\t\t";
for(auto& Y: {Ys...})
cout << Y[i] << "\t\t";
SL;
}
}
/// ////////////////////////////////////////////*/
/// Rellenador de vectores por interpolacion /////
template <class T>
void interpolar(vector<T>& v,T inicio,T incremento,T fin)
{
v.resize( 1 + (int)(fin-inicio)/(int)incremento );
T x = inicio;
for(auto& i:v)
{
i = x;
x += incremento;
}
}
/// ////////////////////////////////////////////*/
| [
"noreply@github.com"
] | noreply@github.com |
232aae9baacfbc7126aabbc194d9ed2a4bae2143 | 2b4dd17b278dee70383b866c9ed0ca8cae3ddd1e | /src/client/OW_BinaryCIMOMHandle.hpp | b2cc98eebe5c05470b43e156a41f49643806c0b0 | [
"BSD-3-Clause"
] | permissive | murisfurder/openwbem | 165344e13f9b189be3a4b5a8ee65ace2c490d64d | 5c688eefc1f8e35a4b1c58529aae5f114c25c2a8 | refs/heads/master | 2021-01-16T23:00:11.194124 | 2012-09-27T10:59:55 | 2012-09-27T12:36:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29,109 | hpp | /*******************************************************************************
* Copyright (C) 2001-2004 Vintela, Inc. 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 Vintela, 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 Vintela, Inc. OR THE 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 Jon Carey
* @author Dan Nuffer
*/
#ifndef OW_BINARYCIMOMHANDLE_HPP_
#define OW_BINARYCIMOMHANDLE_HPP_
#include "OW_config.h"
#include "OW_ClientCIMOMHandle.hpp"
#include "OW_CIMProtocolIFC.hpp"
namespace OW_NAMESPACE
{
class OW_CLIENT_API BinaryCIMOMHandle : public ClientCIMOMHandle
{
public:
/**
* Create a remote CIMOM handle. This represents a single
* connection to a CIMOM.
* @param prot An Reference to a CIMProtocol to be used
* with this remote handle. This will typically be an IPCClient.
* @example
* String url("ipc://user:pass@localhost");
* Reference<HTTPClient> clientRef(new IPCClient(url));
* BinaryCIMOMHandle rch(clientRef);
* // now the binary over ipc connection is established, and
* // the remote CIMOM handle can be used.
*/
BinaryCIMOMHandle( const CIMProtocolIFCRef& prot );
/**
* Get a Reference to the WBEM protocol handler (HTTPClient)
*/
virtual CIMProtocolIFCRef getWBEMProtocolHandler() const;
/**
* Close the connetion to the CIMOM. This will free resources used for the
* client session.
*/
virtual void close();
#ifndef OW_DISABLE_QUALIFIER_DECLARATION
/**
* Deletes the CIM qualfier for the object specified by the CIM object path.
* @param path The CIMObjectPath identifying the qualifier type to delete.
* @exception CIMException If the qualifier type does not exist.
*/
virtual void deleteQualifierType(const String& ns, const String& qualName);
/**
* Updates the specified CIM qualifier type to the specified
* namespace.
* @param name Am CIMObjectPath that identifies the CIM qualifier type.
* @param qt The CIM qualifier type to be updated.
* @exception CIMException If the qualifier type cannot be found or the
* user does not have write permission to the
* namespace.
*/
virtual void setQualifierType(const String& ns,
const CIMQualifierType &qt);
/**
* Enumerates the qualifiers defined in a namespace.
* @param path The CIMObjectPath identifying the namespace whose qualifier
* definitions are to be enumerated.
* @exception CIMException If the specified CIMObjectPath cannot be
* found
*/
virtual void enumQualifierTypes(
const String& ns,
CIMQualifierTypeResultHandlerIFC& result);
#endif // #ifndef OW_DISABLE_QUALIFIER_DECLARATION
/**
* Enumerates the class specified by the CIMObjectPath.
* @param path The CIMObjectPath identifying the class to be enumerated.
* @param deep If set to DEEP, the enumeration returned will
* contain the names of all classes derived from the enumerated class.
* If set to SHALLOW the enumermation will return only
* the names of the first level children of the enumerated class.
* @param localOnly If set to LOCAL_ONLY, only the non-inherited properties
* are returned on each instance, otherwise all properties are returned.
* @param includeQualifiers If set toWBEMFlags::E_INCLUDE_QUALIFIERS, then all class,
* property and method qualifiers will be returned.
* @param includeClassOrigin If true, then the class origin attribute will
* be included with all appropriate elements of each class.
* @exception CIMException If the specified CIMObjectPath object cannot
* be found
*/
virtual void enumClass(const String& ns,
const String& className,
CIMClassResultHandlerIFC& result,
WBEMFlags::EDeepFlag deep = WBEMFlags::E_SHALLOW,
WBEMFlags::ELocalOnlyFlag localOnly = WBEMFlags::E_NOT_LOCAL_ONLY,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers = WBEMFlags::E_INCLUDE_QUALIFIERS,
WBEMFlags::EIncludeClassOriginFlag includeClassOrigin = WBEMFlags::E_INCLUDE_CLASS_ORIGIN);
/**
* Enumerates the class specified by the CIMObjectPath.
* @param path The CIMObjectPath identifying the class to be
* enumerated.
* @param deep If set to CIMClient::DEEP, the enumeration returned will
* contain the names of all classes derived from the
* enumerated class. If set to CIMClient::SHALLOW the
* enumermation will return only the names of the first level
* children of the enumerated class.
* @exception CIMException If the specified CIMObjectPath object cannot be found.
*/
virtual void enumClassNames(
const String& ns,
const String& className,
StringResultHandlerIFC& result,
WBEMFlags::EDeepFlag deep=WBEMFlags::E_DEEP);
/**
* Gets the CIM instance for the specified CIM object path.
*
* @param name the CIMObjectPath that identifies this CIM instance
*
* @param localOnly If true, only the non-inherited properties are returned,
* otherwise all properties are returned.
*
* @param includeQualifiers If true, then all of the qualifiers from the
* class will be returned with the instance
*
* @param includeClassOrigin If true, then the class origin attribute will
* be returned on all appropriate elements
*
* @param propertyList If not NULL and has 0 or more elements, the returned
* instance will not contain properties missing from this list. If not NULL
* and it contains NO elements, then no properties will be included in the
* instance. If propertyList IS NULL, then it is ignored and all properties
* are returned with the instance subject to constraints specified in the
* other parameters.
*
* @return The CIMInstance identified by the CIMObjectPath
* @exception CIMException If the specified CIMObjectPath cannot be
* found
*/
virtual CIMInstance getInstance(
const String& ns,
const CIMObjectPath& instanceName,
WBEMFlags::ELocalOnlyFlag localOnly = WBEMFlags::E_NOT_LOCAL_ONLY,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers = WBEMFlags::E_EXCLUDE_QUALIFIERS,
WBEMFlags::EIncludeClassOriginFlag includeClassOrigin = WBEMFlags::E_EXCLUDE_CLASS_ORIGIN,
const StringArray* propertyList=0);
/**
* Returns all instances (the whole instance and not just the names)
* belonging to the class specified in the path. This could include
* instances of all the classes in the specified class' hierarchy.
*
* @param path The CIMObjectPath identifying the class whose instances are
* to be enumerated.
*
* @param deep If set to CIMClient::DEEP, the enumeration returned will
* contain instances of the specified class and all classes derived from it.
* If set to CIMClient::SHALLOW only instances belonging to the specified
* class are returned.
*
* @param localOnly if true, only the non-inherited properties are returned
* on each instance, otherwise all properties are returned.
*
* @param includeQualifiers If true, then all of the qualifiers from the
* class will be returned with the each instance.
*
* @param includeClassOrigin If true, then the class origin attribute will
* be returned on all appropriate elements.
*
* @param propertyList If not NULL and has 0 or more elements, the returned
* instances will not contain properties missing from this list. If not NULL
* and it contains NO elements, then no properties will be included in the
* instances. If propertyList IS NULL, then it is ignored and all properties
* are returned with the instances subject to constraints specified in the
* other parameters.
*
* @exception CIMException If the object cannot be found
*/
virtual void enumInstances(
const String& ns,
const String& className,
CIMInstanceResultHandlerIFC& result,
WBEMFlags::EDeepFlag deep = WBEMFlags::E_DEEP,
WBEMFlags::ELocalOnlyFlag localOnly = WBEMFlags::E_NOT_LOCAL_ONLY,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers = WBEMFlags::E_EXCLUDE_QUALIFIERS,
WBEMFlags::EIncludeClassOriginFlag includeClassOrigin = WBEMFlags::E_EXCLUDE_CLASS_ORIGIN,
const StringArray* propertyList=0);
/**
* Gets the CIM qualifier type specified in the CIM object path.
* @param name The CIMObjectPath that identifies the CIM qualifier type.
* @return An CIMQualifierType identified by name.
* @exception CIMException If the CIM qualifier type cannot be found
*/
virtual CIMQualifierType getQualifierType(const String& ns,
const String& qualifierName);
/**
* Returns all instances (the the names)
* belonging to the class specified in the path. This could include
* instances of all the classes in the specified class' hierarchy.
*
* @param path The CIMObjectPath identifying the class whose
* instances are to be enumerated.
* @exception CIMException If the object cannot be found
*/
virtual void enumInstanceNames(
const String& ns,
const String& className,
CIMObjectPathResultHandlerIFC& result);
/**
* Gets the CIM class for the specified CIM object path.
* @param name The CIMObjectPath that identifies the CIM class
* @param localOnly If set to LOCAL_ONLY, only the non-inherited properties
* and methods are returned, otherwise all properties and methods are
* returned.
* @param includeQualifiers If set toWBEMFlags::E_INCLUDE_QUALIFIERS, then all class,
* property and method qualifiers will be included in the CIMClass.
* Otherwise qualifiers will be excluded.
* @param includeClassOrigin If true, then the classOrigin attribute will
* be present on all appropriate elements of the CIMClass
* @param propertyList If not NULL, only properties contained in this array
* will be included in the CIMClass. If NULL, all properties will
* be returned.
* @return CIMClass the CIM class indentified by the CIMObjectPath
* @exception CIMException If the namespace or the model path identifying
* the object cannot be found
*/
virtual CIMClass getClass(
const String& ns,
const String& className,
WBEMFlags::ELocalOnlyFlag localOnly = WBEMFlags::E_NOT_LOCAL_ONLY,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers = WBEMFlags::E_INCLUDE_QUALIFIERS,
WBEMFlags::EIncludeClassOriginFlag includeClassOrigin = WBEMFlags::E_INCLUDE_CLASS_ORIGIN,
const StringArray* propertyList=NULL);
/**
* Executes the specified method on the specified object. A method is a
* declaration containing the method name, return type, and parameters in
* the method.
* @param name An CIMObjectPath that identifies the method
* @param methodName The string name of the method to be invoked
* @param inParams The input parameters specified as an CIMValueArray.
* @param outParams The output parameters.
* @return A non-null CIMValue on success. Otherwise a null CIMValue.
* @exception CIMException If the specified method cannot be found
*/
virtual CIMValue invokeMethod(
const String& ns,
const CIMObjectPath& path,
const String &methodName, const CIMParamValueArray &inParams,
CIMParamValueArray &outParams);
#ifndef OW_DISABLE_SCHEMA_MANIPULATION
/**
* Adds the CIM class to the specified namespace.
* @param name An CIMObjectPath that identifies the CIM class to be added.
* @param cc The CIMClass to be added
* @exception CIMException If the CIM class already exists in the
* namespace.
*/
virtual void createClass(const String& ns,
const CIMClass &cc);
/**
* Updates the CIM class associated with the specified namespace.
* @param name An CIMObjectPath that identifies the CIM class to be
* updated.
* @param cc The CIMClass to be updated
* @exception CIMException If the class does not exists
*/
virtual void modifyClass(const String &ns, const CIMClass &cc);
/**
* @param ns The namespace containing the class to delete.
* @param className The class to delete
* @exception CIMException If the object does not exist
*/
virtual void deleteClass(const String& ns, const String& className);
#endif // #ifndef OW_DISABLE_SCHEMA_MANIPULATION
#ifndef OW_DISABLE_INSTANCE_MANIPULATION
/**
* Add the specified CIM instance to the specified namespace.
* @param name The CIMObjectPath that identifies the CIM instance to be
* added.
* @param ci the CIMInstance to be added
* @return An CIMObjectPath of the created instance.
* @exception CIMException If the CIM instance already exists in the
* namespace
*/
virtual CIMObjectPath createInstance(const String& ns,
const CIMInstance &ci);
/**
* Update the specified CIM instance associated with the specified
* namespace.
* @param name An CIMObjectPath that identifies the CIM instance to be
* updated.
* @param ci The CIMInstance to be updated.
* @exception CIMException
*/
virtual void modifyInstance(
const String& ns,
const CIMInstance& modifiedInstance,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers,
const StringArray* propertyList);
/**
* Deletes the CIM instance specified by the CIM object path.
* A CIM object path consists of two parts: namespace + model path. The
* model path is created by concatenating the properties of a class that are
* qualified with the KEY qualifier.
* @param path The CIMObjectPath identifying the instance to delete.
* @exception CIMException If the instance does not exist.
*/
virtual void deleteInstance(const String& ns, const CIMObjectPath &path);
#if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
/**
* Set the specified CIM instance property.
* @param name An CIMObjectPath that identifies the CIM instance
* to be accessed
* @param propertyName The name of the property to set the value on.
* @param newValue The new value for property propertyName.
* @exception CIMException
*/
virtual void setProperty(
const String& ns,
const CIMObjectPath &name,
const String &propertyName, const CIMValue &cv);
#endif // #if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
#endif // #ifndef OW_DISABLE_INSTANCE_MANIPULATION
#if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
/**
* Get the specified CIM instance property.
* @param name An CIMObjectPath that identifies the CIM instance
* to be accessed
* @param propertyName The name of the property to retrieve.
* @return The CIMvalue for property identified by propertyName.
* @exception CIMException
*/
virtual CIMValue getProperty(
const String& ns,
const CIMObjectPath &name,
const String &propertyName);
#endif // #if !defined(OW_DISABLE_PROPERTY_OPERATIONS)
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
/**
* This operation is used to enumerate CIMInstances
* that are associated to a particular source CIM Object.
*
* @param objectName Defines the source CIM Object whose associated Instances
* are to be returned. This may be either a Class name or Instance name
* (modelpath).
*
* @param assocClass The AssocClass input parameter, if not "", MUST be a
* valid CIM Association Class name. It acts as a filter on the returned set
* of Objects by mandating that each returned Object MUST be associated to
* the source Object via an Instance of this Class or one of its subclasses.
*
* @param resultClass The ResultClass input parameter, if not "", MUST be
* a valid CIM Class name. It acts as a filter on the returned set of
* Objects by mandating that each returned Object MUST be either an Instance
* of this Class (or one of its subclasses) or be this Class (or one of its
* subclasses).
*
* @param role The Role input parameter, if not "", MUST be a valid
* Property name. It acts as a filter on the returned set of Objects by
* mandating that each returned Object MUST be associated to the source
* Object via an Association in which the source Object plays the specified
* role (i.e. the name of the Property in the Association Class that refers
* to the source Object MUST match the value of this parameter).
*
* @param resultRole The ResultRole input parameter, if not NULL, "" be a
* valid Property name. It acts as a filter on the returned set of Objects
* by mandating that each returned Object MUST be associated to the source
* Object via an Association in which the returned Object plays the
* specified role (i.e. the name of the Property in the Association Class
* that refers to the returned Object MUST match the value of this
* parameter).
*
* @param includeQualifiers If the IncludeQualifiers input parameter is true
* this specifies that all Qualifiers for each Object (including Qualifiers
* on the Object and on any returned Properties) MUST be included as
* elements in the response.If false no elements are present in each
* returned Object.
*
* @param includeClassOrigin If the IncludeClassOrigin input parameter is
* true, this specifies that the CLASSORIGIN attribute MUST be present on
* all appropriate elements in each returned Object. If false, no
* CLASSORIGIN attributes are present in each returned Object.
*
* @param propertyList If the PropertyList input parameter is not NULL, the
* members of the array define one or more Property names. Each returned
* Object MUST NOT include elements for any Properties missing from this
* list. Note that if LocalOnly is specified as true (or DeepInheritance is
* specified as false) this acts as an additional filter on the set of
* Properties returned (for example, if Property A is included in the
* PropertyList but LocalOnly is set to true and A is not local to a
* returned Instance, then it will not be included in that Instance). If the
* PropertyList input parameter is an empty array this signifies that no
* Properties are included in each returned Object. If the PropertyList input
* parameter is NULL this specifies that all Properties (subject to the
* conditions expressed by the other parameters) are included in each
* returned Object. If the PropertyList contains duplicate elements, the
* Server ignores the duplicates but otherwise process the request normally.
* If the PropertyList contains elements which are invalid Property names for
* any target Object, the Server ignores such entries but otherwise process
* the request normally. Clients SHOULD NOT explicitly specify properties in
* the PropertyList parameter unless they have specified a non-NULL value for
* the ResultClass parameter.
*
* @return If successful, the method returns zero or more CIM Instances
* meeting the requested criteria.
*
* @exception CIMException. The following IDs can be expected.
* CIM_ERR_ACCESS_DENIED CIM_ERR_NOT_SUPPORTED CIM_ERR_INVALID_NAMESPACE
* CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or
* otherwise incorrect parameters) CIM_ERR_FAILED (some other unspecified
* error occurred)
*/
virtual void associators(
const String& ns,
const CIMObjectPath &path,
CIMInstanceResultHandlerIFC& result,
const String &assocClass, const String &resultClass,
const String &role, const String &resultRole,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers, WBEMFlags::EIncludeClassOriginFlag includeClassOrigin,
const StringArray* propertyList);
virtual void associatorsClasses(
const String& ns,
const CIMObjectPath& path,
CIMClassResultHandlerIFC& result,
const String& assocClass=String(),
const String& resultClass=String(),
const String& role=String(),
const String& resultRole=String(),
WBEMFlags::EIncludeQualifiersFlag includeQualifiers=WBEMFlags::E_EXCLUDE_QUALIFIERS,
WBEMFlags::EIncludeClassOriginFlag includeClassOrigin=WBEMFlags::E_EXCLUDE_CLASS_ORIGIN,
const StringArray* propertyList=0);
/**
* This operation is used to enumerate the association objects that refer to
* a particular target CIM Object (Class or Instance).
*
* @param objectName The ObjectName input parameter defines the target CIM
* Object whose referring Objects are to be returned. This is either a Class
* name or Instance name (model path).
*
* @param resultClass The ResultClass input parameter, if not NULL, MUST be
* a valid CIM Class name. It acts as a filter on the returned set of
* Objects by mandating that each returned Object MUST be an Instance of this
* Class (or one of its subclasses), or this Class (or one of its
* subclasses).
*
* @param role The Role input parameter, if not NULL, MUST be a valid
* Property name. It acts as a filter on the returned set of Objects by
* mandating that each returned Objects MUST refer to the target Object via
* a Property whose name matches the value of this parameter.
*
* @param includeQualifiers Refer to includeQualifiers for associators.
*
* @param includeClassOrigin Refer to includeQualifiers for associators.
*
* @param propertyList Refer to includeQualifiers for associators.
*
* @return If successful, the method returns zero or more CIM Classes or
* Instances meeting the requested criteria.
*
* @exception CIMException - as defined for associators method.
*/
virtual void references(
const String& ns,
const CIMObjectPath &path,
CIMInstanceResultHandlerIFC& result,
const String &resultClass, const String &role,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers, WBEMFlags::EIncludeClassOriginFlag includeClassOrigin,
const StringArray* propertyList);
/**
* This operation is used to enumerate the association objects that refer to
* a particular target CIM Object (Class or Instance).
* @param objectName refer to reference method.
* @param resultClass refer to reference method.
* @param role refer to reference method.
*
* @return If successful, the method returns the names of zero or more full
* CIM Class paths or Instance paths of Objects meeting the requested
* criteria.
*
* @exception CIMException As defined for associators method.
*/
virtual void referenceNames(
const String& ns,
const CIMObjectPath &path,
CIMObjectPathResultHandlerIFC& result,
const String &resultClass,
const String &role);
virtual void referencesClasses(
const String& ns,
const CIMObjectPath &path,
CIMClassResultHandlerIFC& result,
const String &resultClass, const String &role,
WBEMFlags::EIncludeQualifiersFlag includeQualifiers, WBEMFlags::EIncludeClassOriginFlag includeClassOrigin,
const StringArray* propertyList);
/**
* This method is used to enumerate the names of CIM Objects (Classes or
* Instances) that are associated to a particular CIM Object.
*
* @param path Defines the source CIM Object whose associated Objects are to
* be returned. This may be either a Class name or Instance name (modelpath).
*
* @param assocClass The AssocClass input parameter, if not NULL, MUST be a
* valid CIM Association Class name. It acts as a filter on the returned set
* of Objects by mandating that each returned Object MUST be associated to
* the source Object via an Instance of this Class or one of its subclasses.
*
* @param resultClass The ResultClass input parameter, if not NULL, MUST be
* a valid CIM Class name. It acts as a filter on the returned set of
* Objects by mandating that each returned Object MUST be either an Instance
* of this Class (or one of its subclasses) or be this Class (or one of its
* subclasses).
*
* @param role The Role input parameter, if not NULL, MUST be a valid
* Property name. It acts as a filter on the returned set of Objects by
* mandating that each returned Object MUST be associated to the source
* Object via an Association in which the source Object plays the specified
* role (i.e. the name of the Property in the Association Class that refers
* to the source Object MUST match the value of this parameter).
*
* @param resultRole The ResultRole input parameter, if not NULL, MUST be a
* valid Property name. It acts as a filter on the returned set of Objects
* by mandating that each returned Object MUST be associated to the source
* Object via an Association in which the returned Object plays the
* specified role (i.e. the name of the Property in the Association Class
* that refers to the returned Object MUST match the value of this
* parameter).
*
* @return If successful, the method returns zero or more full CIM Class
* paths or Instance paths of Objects meeting the requested
* criteria.
*
* @exception CIMException - as defined in the associator method
*/
virtual void associatorNames(
const String& ns,
const CIMObjectPath &path,
CIMObjectPathResultHandlerIFC& result,
const String &assocClass,
const String &resultClass, const String &role,
const String &resultRole);
#endif // #ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
/**
* Executes a query to retrieve objects. The WBEM Query Language (WQL) is a
* subset of standard American National Standards Institute Structured Query
* Language (ANSI SQL) with semantic changes to support WBEM on Solaris.
* Only queries on class instances are supported.
*
* @param path CIMNameSpace that identifies the namespace in which to query.
*
* @param query A string containing the text of the query. This parameter
* cannot be null.
*
* @param wqlLevel - Static integer that identifies the query language to use for
* parsing the query string. WQL levels 1 and 2 are the only currently supported
* query language.
*
* @return CIMInstanceArray A deep enumeration of all instances of the specified
* class and all classes derived from the specified class, that match the
* query string.
*
* @exception CIMException If any of the following errors occur:
* The user does not have permission to view the result.
* The requested query language is not supported.
* The query specifies a class that does not exist.
*/
CIMInstanceEnumeration execQuery(
const String& ns,
const String &query, int wqlLevel);
/**
* Executes a query to retrieve or modify objects.
*
* @param ns CIMNameSpace that identifies the namespace in which to query.
*
* @param query A string containing the text of the query. This parameter
* cannot be null.
*
* @param queryLanguage A string containing the query language the query is
* written in.
*
* @return CIMInstanceArray A deep enumeration of all instances of the specified
* class and all classes derived from the specified class, that match the
* query string.
*
* @exception CIMException If any of the following errors occur:
* The user does not have permission to view the result.
* The requested query language is not supported.
* The query specifies a class that does not exist.
*/
virtual void execQuery(
const String& ns,
CIMInstanceResultHandlerIFC& result,
const String& query, const String& queryLanguage);
virtual CIMFeatures getServerFeatures();
/**
* Set/Add an HTTP header and its associated value. This header will be
* sent to the CIMOM on every request.
* @param hdrName The name of the HTTP Header (e.g. "Accept-Language")
* @param hdrValue The value of the HTTP Header (e.g. "en-US, en")
* @return true if successful. Otherwise false.
*/
virtual bool setHTTPRequestHeader(const String& hdrName,
const String& hdrValue);
/**
* Get the value of an HTTP header that was returned in the CIMOM's
* response.
* @param hdrName The of the HTTP Header value to retrieve.
* (e.g. "Content-Language")
* @param valueOut An output param that will hold the value of the header
* on return.
* @return true if the header exists. Otherwise false.
*/
virtual bool getHTTPResponseHeader(const String& hdrName,
String& valueOut) const;
private:
#ifdef OW_WIN32
#pragma warning (push)
#pragma warning (disable: 4251)
#endif
CIMProtocolIFCRef m_protocol;
#ifdef OW_WIN32
#pragma warning (pop)
#endif
};
} // end namespace OW_NAMESPACE
#endif
| [
"kkaempf@suse.de"
] | kkaempf@suse.de |
df9ad1e8710ca01634e86777ef134745945e7611 | 4ed3c8ff8fe86b41f912e393a85fd5598aaafc75 | /lib/casadi-py27-np1.9.1-v3.0.0/include/casadi/core/function/qpsol_impl.hpp | 99a22ce388c09ea0c1d3fc80ad7bfbb5ef90909a | [
"BSD-3-Clause"
] | permissive | njoubert/spooky | a2e3245c1539406c2512f863eb69be76180f6fc7 | 308bcf8d53734f680edb9093e5ab7221e763a8b6 | refs/heads/master | 2021-01-22T14:10:40.197554 | 2017-05-31T21:45:10 | 2017-05-31T21:45:10 | 45,371,821 | 18 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 3,594 | hpp | /*
* This file is part of CasADi.
*
* CasADi -- A symbolic framework for dynamic optimization.
* Copyright (C) 2010-2014 Joel Andersson, Joris Gillis, Moritz Diehl,
* K.U. Leuven. All rights reserved.
* Copyright (C) 2011-2014 Greg Horn
*
* CasADi is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* CasADi 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with CasADi; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifndef CASADI_QPSOL_IMPL_HPP
#define CASADI_QPSOL_IMPL_HPP
#include "qpsol.hpp"
#include "function_internal.hpp"
#include "plugin_interface.hpp"
/// \cond INTERNAL
namespace casadi {
/// Internal class
class CASADI_EXPORT Qpsol : public FunctionInternal, public PluginInterface<Qpsol> {
public:
// Constructor
Qpsol(const std::string& name, const std::map<std::string, Sparsity> &st);
// Destructor
virtual ~Qpsol() = 0;
///@{
/** \brief Number of function inputs and outputs */
virtual size_t get_n_in() { return QPSOL_NUM_IN;}
virtual size_t get_n_out() { return QPSOL_NUM_OUT;}
///@}
/// @{
/** \brief Sparsities of function inputs and outputs */
virtual Sparsity get_sparsity_in(int i);
virtual Sparsity get_sparsity_out(int i);
/// @}
///@{
/** \brief Names of function input and outputs */
virtual std::string get_name_in(int i) { return qpsol_in(i);}
virtual std::string get_name_out(int i) { return qpsol_out(i);}
/// @}
///@{
/** \brief Options */
static Options options_;
virtual const Options& get_options() const { return options_;}
///@}
// Initialize
virtual void init(const Dict& opts);
/// \brief Check if the numerical values of the supplied bounds make sense
virtual void checkInputs(const double* lbx, const double* ubx,
const double* lba, const double* uba) const;
/** Generate native code in the interfaced language for debugging */
virtual void generateNativeCode(std::ostream& file) const;
// Creator function for internal class
typedef Qpsol* (*Creator)(const std::string& name,
const std::map<std::string, Sparsity>& st);
// No static functions exposed
struct Exposed{ };
/// Collection of solvers
static std::map<std::string, Plugin> solvers_;
/// Infix
static const std::string infix_;
/// Short name
static std::string shortname() { return "qpsol";}
/** \brief Get default input value */
virtual double default_in(int ind) const;
/// Can discrete variables be treated
virtual bool integer_support() const { return false;}
protected:
/// Options
std::vector<bool> discrete_;
/// Problem structure
Sparsity H_, A_;
/// Number of decision variables
int n_;
/// The number of constraints (counting both equality and inequality) == A.size1()
int nc_;
};
} // namespace casadi
/// \endcond
#endif // CASADI_QPSOL_IMPL_HPP
| [
"njoubert@gmail.com"
] | njoubert@gmail.com |
9aaf6393435dc39e2c4e7da369f5c20469de6e7f | d3363534cb895b3b9acbb49e70e205a6f5a524b9 | /380/380.cpp | 186ab509a05f1f9ac523c2c6d62677e204677657 | [] | no_license | Behrouz-Babaki/practice | 82a638cbd6a7475930c0fd30fcd86a4333786b7b | 27174701c6aeb0dcea2335e27dbcf9ffa3d7f73a | refs/heads/master | 2021-08-16T11:38:31.981301 | 2017-11-19T19:37:19 | 2017-11-19T19:37:19 | 12,410,348 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,247 | cpp | #include <iostream>
#include <map>
#include <vector>
#include <sstream>
#include <string>
using std::endl;
using std::cin;
using std::ws;
using std::cout;
using std::map;
using std::vector;
using std::istringstream;
using std::getline;
using std::string;
struct _forward_ {
int time;
int duration;
int target;
};
typedef struct _forward_ forward;
map<int, vector<forward> > m;
int find(int original, int time, int extension);
void print(int num);
int main(void) {
int num_cases;
cin >> num_cases >> ws;
cout << "CALL FORWARDING OUTPUT" << endl;
for (int case_counter=1; case_counter<=num_cases; case_counter++){
}
cout << "END OF OUTPUT" << endl;
return 0;
}
int find(int original, int time, int extension) {
if (extension == original)
return 9999;
if (m.find(extension)!=m.end())
for (auto forward : m[extension])
if (time >= forward.time && time <= forward.time+forward.duration)
if (original == 9999)
return find(extension, time, forward.target);
else
return find(original, time, forward.target);
return extension;
}
void print(int num) {
int copy = num;
int count = 0;
while (copy){
copy/=10;
count++;
}
for(int i=0; i<4-count; i++)
cout << "0";
cout << num;
}
| [
"Behrouz.Babaki@cs.kuleuven.be"
] | Behrouz.Babaki@cs.kuleuven.be |
1099f3e2c203cab1defb9d80919a6eb23021ce0c | 5cbecad99f964c0a7f3c796007a060e159e169eb | /src/wallet/api/address_book.h | 5dbf8fdfa3257a53503782dd2df00530d4d14805 | [
"BSD-3-Clause"
] | permissive | Pubfred/Zeon2 | 0dfa9f53a6d15ed572b84936c1df4791ef82fc12 | 1ea7f7efbe4f572657c56d134837f8a1276f6fca | refs/heads/master | 2021-01-01T19:22:22.244901 | 2017-07-27T20:08:21 | 2017-07-27T20:08:21 | 98,575,149 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,585 | h | // Copyright (c) 2016-2017, ZEON, (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 "wallet/wallet2_api.h"
#include "wallet/wallet2.h"
namespace Monero {
class WalletImpl;
class AddressBookImpl : public AddressBook
{
public:
AddressBookImpl(WalletImpl * wallet);
~AddressBookImpl();
// Fetches addresses from Wallet2
void refresh();
std::vector<AddressBookRow*> getAll() const;
bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description);
bool deleteRow(int rowId);
// Error codes. See AddressBook:ErrorCode enum in wallet2_api.h
std::string errorString() const {return m_errorString;}
int errorCode() const {return m_errorCode;}
private:
void clearRows();
void clearStatus();
private:
WalletImpl *m_wallet;
std::vector<AddressBookRow*> m_rows;
std::string m_errorString;
int m_errorCode;
};
}
namespace Bitmonero = Monero;
| [
"pubfree@free.fr"
] | pubfree@free.fr |
5a3c4fddcb4cb97045509b86edd1a8840259c975 | 0354d8e29fcbb65a06525bcac1f55fd08288b6e0 | /clients/qt5cpp/generated/client/HudsonMasterComputer.h | 9ce14fb6b35b036395fa9f3f4c75b2d16b619e1f | [
"MIT"
] | permissive | zhiwei55/swaggy-jenkins | cdc52956a40e947067415cec8d2da1425b3d7670 | 678b5477f5f9f00022b176c34b840055fb1b0a77 | refs/heads/master | 2020-03-06T20:38:53.012467 | 2018-02-19T01:53:33 | 2018-02-19T01:54:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,876 | h | /**
* Swaggy Jenkins
* Jenkins API clients generated from Swagger / Open API specification
*
* OpenAPI spec version: 0.1.0
* Contact: blah@cliffano.com
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
/*
* HudsonMasterComputer.h
*
*
*/
#ifndef HudsonMasterComputer_H_
#define HudsonMasterComputer_H_
#include <QJsonObject>
#include "HudsonMasterComputerexecutors.h"
#include "HudsonMasterComputermonitorData.h"
#include "Label1.h"
#include <QList>
#include <QString>
#include "SWGObject.h"
namespace Swagger {
class HudsonMasterComputer: public SWGObject {
public:
HudsonMasterComputer();
HudsonMasterComputer(QString* json);
virtual ~HudsonMasterComputer();
void init();
void cleanup();
QString asJson ();
QJsonObject* asJsonObject();
void fromJsonObject(QJsonObject &json);
HudsonMasterComputer* fromJson(QString &jsonString);
QString* getClass();
void setClass(QString* _class);
QString* getDisplayName();
void setDisplayName(QString* display_name);
QList<HudsonMasterComputerexecutors*>* getExecutors();
void setExecutors(QList<HudsonMasterComputerexecutors*>* executors);
QString* getIcon();
void setIcon(QString* icon);
QString* getIconClassName();
void setIconClassName(QString* icon_class_name);
bool getIdle();
void setIdle(bool idle);
bool getJnlpAgent();
void setJnlpAgent(bool jnlp_agent);
bool getLaunchSupported();
void setLaunchSupported(bool launch_supported);
Label1* getLoadStatistics();
void setLoadStatistics(Label1* load_statistics);
bool getManualLaunchAllowed();
void setManualLaunchAllowed(bool manual_launch_allowed);
HudsonMasterComputermonitorData* getMonitorData();
void setMonitorData(HudsonMasterComputermonitorData* monitor_data);
qint32 getNumExecutors();
void setNumExecutors(qint32 num_executors);
bool getOffline();
void setOffline(bool offline);
QString* getOfflineCause();
void setOfflineCause(QString* offline_cause);
QString* getOfflineCauseReason();
void setOfflineCauseReason(QString* offline_cause_reason);
bool getTemporarilyOffline();
void setTemporarilyOffline(bool temporarily_offline);
private:
QString* _class;
QString* display_name;
QList<HudsonMasterComputerexecutors*>* executors;
QString* icon;
QString* icon_class_name;
bool idle;
bool jnlp_agent;
bool launch_supported;
Label1* load_statistics;
bool manual_launch_allowed;
HudsonMasterComputermonitorData* monitor_data;
qint32 num_executors;
bool offline;
QString* offline_cause;
QString* offline_cause_reason;
bool temporarily_offline;
};
}
#endif /* HudsonMasterComputer_H_ */
| [
"cliffano@gmail.com"
] | cliffano@gmail.com |
63b6c24afd6dedaec3e6cd0a345c259ac122b153 | b13a84e6098030c5df2b38d5dcb1b16951115190 | /lib/range.hpp | 7a7ba85b5a681c2b88032e28602cac27dcc47e9c | [] | no_license | cctry/SCpaper-2021 | 7b35e9e009256f86187f96722818f610ab3e3dd4 | aedab163f44bff8dfad3745d4f57972cb7640cda | refs/heads/main | 2023-04-30T05:44:26.769453 | 2021-06-03T02:17:22 | 2021-06-03T02:17:22 | 356,388,712 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,584 | hpp | #pragma once
#include "utils.h"
#include <iterator>
#include <type_traits>
// Make these ranges usable inside CUDA C++ device code
#ifdef __CUDACC__
#define DEVICE_CALLABLE __host__ __device__
#else
#define DEVICE_CALLABLE
#endif
namespace culib {
namespace detail {
template <typename T>
struct range_iter_base : std::iterator<std::input_iterator_tag, T> {
DEVICE_CALLABLE
range_iter_base(T current) : current(current) {}
DEVICE_CALLABLE
T operator*() const { return current; }
DEVICE_CALLABLE
T const *operator->() const { return ¤t; }
DEVICE_CALLABLE
range_iter_base &operator++() {
++current;
return *this;
}
DEVICE_CALLABLE
range_iter_base operator++(int) {
auto copy = *this;
++*this;
return copy;
}
DEVICE_CALLABLE
bool operator==(range_iter_base const &other) const {
return current == other.current;
}
DEVICE_CALLABLE
bool operator!=(range_iter_base const &other) const {
return not(*this == other);
}
protected:
T current;
};
} // namespace detail
template <typename T> struct range_proxy {
struct iter : detail::range_iter_base<T> {
DEVICE_CALLABLE
iter(T current) : detail::range_iter_base<T>(current) {}
};
struct step_range_proxy {
struct iter : detail::range_iter_base<T> {
DEVICE_CALLABLE
iter(T current, T step)
: detail::range_iter_base<T>(current), step(step) {}
using detail::range_iter_base<T>::current;
DEVICE_CALLABLE
iter &operator++() {
current += step;
return *this;
}
DEVICE_CALLABLE
iter operator++(int) {
auto copy = *this;
++*this;
return copy;
}
// Loses commutativity. Iterator-based ranges are simply broken. :-(
DEVICE_CALLABLE
bool operator==(iter const &other) const {
return step > 0 ? current >= other.current
: current < other.current;
}
DEVICE_CALLABLE
bool operator!=(iter const &other) const {
return not(*this == other);
}
private:
T step;
};
DEVICE_CALLABLE
step_range_proxy(T begin, T end, T step)
: begin_(begin, step), end_(end, step) {}
DEVICE_CALLABLE
iter begin() const { return begin_; }
DEVICE_CALLABLE
iter end() const { return end_; }
private:
iter begin_;
iter end_;
};
DEVICE_CALLABLE
range_proxy(T begin, T end) : begin_(begin), end_(end) {}
DEVICE_CALLABLE
step_range_proxy step(T step) { return {*begin_, *end_, step}; }
DEVICE_CALLABLE
iter begin() const { return begin_; }
DEVICE_CALLABLE
iter end() const { return end_; }
private:
iter begin_;
iter end_;
};
template <typename T> struct infinite_range_proxy {
struct iter : detail::range_iter_base<T> {
DEVICE_CALLABLE
iter(T current = T()) : detail::range_iter_base<T>(current) {}
DEVICE_CALLABLE
bool operator==(iter const &) const { return false; }
DEVICE_CALLABLE
bool operator!=(iter const &) const { return true; }
};
struct step_range_proxy {
struct iter : detail::range_iter_base<T> {
DEVICE_CALLABLE
iter(T current = T(), T step = T())
: detail::range_iter_base<T>(current), step(step) {}
using detail::range_iter_base<T>::current;
DEVICE_CALLABLE
iter &operator++() {
current += step;
return *this;
}
DEVICE_CALLABLE
iter operator++(int) {
auto copy = *this;
++*this;
return copy;
}
DEVICE_CALLABLE
bool operator==(iter const &) const { return false; }
DEVICE_CALLABLE
bool operator!=(iter const &) const { return true; }
private:
T step;
};
DEVICE_CALLABLE
step_range_proxy(T begin, T step) : begin_(begin, step) {}
DEVICE_CALLABLE
iter begin() const { return begin_; }
DEVICE_CALLABLE
iter end() const { return iter(); }
private:
iter begin_;
};
DEVICE_CALLABLE
infinite_range_proxy(T begin) : begin_(begin) {}
DEVICE_CALLABLE
step_range_proxy step(T step) { return step_range_proxy(*begin_, step); }
DEVICE_CALLABLE
iter begin() const { return begin_; }
DEVICE_CALLABLE
iter end() const { return iter(); }
private:
iter begin_;
};
template <typename T> DEVICE_CALLABLE range_proxy<T> range(T begin, T end) {
return {begin, end};
}
template <typename T> DEVICE_CALLABLE infinite_range_proxy<T> range(T begin) {
return {begin};
}
namespace traits {
template <typename C> struct has_size {
template <typename T>
static constexpr auto check(T *) -> typename std::is_integral<
decltype(std::declval<T const>().size())>::type;
template <typename> static constexpr auto check(...) -> std::false_type;
using type = decltype(check<C>(0));
static constexpr bool value = type::value;
};
} // namespace traits
template <typename C,
typename = typename std::enable_if<traits::has_size<C>::value>>
DEVICE_CALLABLE auto indices(C const &cont)
-> range_proxy<decltype(cont.size())> {
return {0, cont.size()};
}
template <typename T, std::size_t N>
DEVICE_CALLABLE range_proxy<std::size_t> indices(T (&)[N]) {
return {0, N};
}
template <typename T>
range_proxy<typename std::initializer_list<T>::size_type>
DEVICE_CALLABLE indices(std::initializer_list<T> &&cont) {
return {0, cont.size()};
}
template <typename T>
using step_range = typename range_proxy<T>::step_range_proxy;
template <typename T>
__device__ step_range<T> grid_stride_range(T begin, T end) {
begin += blockDim.x * blockIdx.x + threadIdx.x;
return range(begin, end).step(gridDim.x * blockDim.x);
}
template <typename T>
__device__ step_range<T> block_stride_range(T begin, T end) {
begin += threadIdx.x;
return range(begin, end).step(blockDim.x);
}
template <typename T>
__device__ step_range<T> warp_stride_range(T begin, T end) {
begin += threadIdx.x % 32;
return range(begin, end).step(32);
}
} // namespace culib | [
"noreply@github.com"
] | noreply@github.com |
54fb2f63d5d4f7304a388b0285d5824f34314909 | 777d1b7f25bf781b3dcba6a10884679cdcbc4810 | /src/apps/public/pepspec/pepspec_anchor_dock.cc | 582467d7415bfa70605c964a1c34e8045fa8eaf8 | [] | no_license | radtek/jMetalRosetta | 84cfc039ff575c4d858fc85abff3f755e75eaec8 | ebb8eaba167e5684da668df03774bddb4d2fa273 | refs/heads/master | 2020-05-27T16:42:49.400393 | 2017-07-31T22:19:13 | 2017-07-31T22:19:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 54,523 | cc | // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
// vi: set ts=2 noet:
//
// (c) Copyright Rosetta Commons Member Institutions.
// (c) This file is part of the Rosetta software suite and is made available under license.
// (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
// (c) For more information, see http://www.rosettacommons.org. Questions about this can be
// (c) addressed to University of Washington CoMotion, email: license@uw.edu.
/// @file
/// @brief
// libRosetta headers
#include <protocols/frags/VallData.hh>
#include <protocols/frags/TorsionFragment.hh>
#include <core/scoring/constraints/CoordinateConstraint.hh>
#include <core/scoring/constraints/ConstraintIO.hh>
#include <core/scoring/func/FlatHarmonicFunc.hh>
#include <protocols/simple_moves/BackboneMover.hh>
#include <protocols/simple_moves/MinMover.hh>
#include <protocols/moves/MonteCarlo.hh>
#include <protocols/moves/Mover.hh>
#include <protocols/moves/MoverContainer.hh>
#include <protocols/moves/OutputMovers.hh>
#include <protocols/rigid/RigidBodyMover.hh>
// #include <protocols/moves/rigid_body_moves.hh>
#include <protocols/moves/TrialMover.hh>
#include <protocols/simple_moves/PackRotamersMover.hh>
#include <protocols/simple_moves/RotamerTrialsMover.hh>
#include <protocols/moves/RepeatMover.hh>
//#include <protocols/loops/ccd_closure.hh>
#include <protocols/loops/loops_main.hh>
#include <protocols/viewer/viewers.hh>
#include <core/types.hh>
#include <core/scoring/sasa.hh>
// #include <core/util/prof.hh> // profiling
// #include <core/util/CacheableData.hh> // profiling
#include <core/chemical/AA.hh>
#include <core/chemical/AtomTypeSet.hh>
#include <core/chemical/AA.hh>
#include <core/conformation/Conformation.hh>
#include <core/conformation/Residue.hh>
#include <core/conformation/ResidueMatcher.hh>
#include <core/conformation/ResidueFactory.hh>
#include <core/pack/rotamer_set/RotamerCouplings.hh>
#include <core/chemical/ResidueType.hh>
#include <core/chemical/ResidueTypeSet.hh>
#include <core/chemical/VariantType.hh>
#include <core/chemical/util.hh>
#include <core/chemical/ChemicalManager.hh>
#include <core/scoring/rms_util.hh>
#include <core/scoring/EnergyMap.hh>
#include <core/scoring/Energies.hh>
#include <core/scoring/etable/Etable.hh>
#include <core/scoring/ScoringManager.hh>
#include <core/scoring/ScoreFunction.hh>
#include <core/scoring/ScoreFunctionFactory.hh>
#include <core/scoring/Ramachandran.hh>
#include <core/pack/dunbrack/RotamerLibrary.hh>
#include <core/pack/dunbrack/RotamerLibraryScratchSpace.hh>
#include <core/scoring/hbonds/HBondSet.hh>
#include <core/scoring/hbonds/hbonds.hh>
#include <core/scoring/etable/count_pair/CountPairFunction.hh>
#include <core/pack/rotamer_trials.hh>
#include <core/pack/pack_rotamers.hh>
#include <core/pack/task/PackerTask.hh>
#include <core/pack/task/TaskFactory.hh>
#include <core/pack/task/operation/TaskOperations.hh>
#include <core/kinematics/RT.hh>
#include <core/kinematics/FoldTree.hh>
#include <core/kinematics/MoveMap.hh>
#include <core/kinematics/util.hh>
#include <core/id/AtomID_Map.hh>
#include <core/pose/Pose.hh>
#include <core/pose/PDBPoseMap.hh>
#include <core/pose/PDBInfo.hh>
#include <core/pose/util.hh>
#include <basic/options/util.hh>//option.hh>
// #include <basic/options/after_opts.hh>
#include <basic/basic.hh>
#include <basic/options/option.hh>
#include <basic/database/open.hh>
#include <devel/init.hh>
#include <core/import_pose/import_pose.hh>
#include <utility/vector1.hh>
#include <utility/file/FileName.hh>
#include <numeric/conversions.hh>
#include <numeric/xyzVector.hh>
#include <numeric/random/random.hh>
#include <numeric/random/random_permutation.hh>
#include <numeric/NumericTraits.hh>
#include <ObjexxFCL/string.functions.hh>
// //REMOVE LATER!
// #include <utility/io/izstream.hh>
#include <core/io/pdb/pdb_writer.hh>
#include <core/id/SequenceMapping.hh>
#include <core/sequence/Sequence.hh>
#include <core/sequence/SequenceAlignment.hh>
#include <core/sequence/NWAligner.hh>
#include <core/sequence/MatrixScoringScheme.hh>
#include <core/sequence/ScoringScheme.fwd.hh>
// // C++ headers
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <string>
#include <sstream>
//silly using/typedef
#include <basic/options/keys/in.OptionKeys.gen.hh>
#include <basic/options/keys/out.OptionKeys.gen.hh>
#include <basic/options/keys/score.OptionKeys.gen.hh>
#include <basic/options/keys/pepspec.OptionKeys.gen.hh>
#include <basic/Tracer.hh>
//Auto Headers
#include <core/pose/util.tmpl.hh>
#include <core/scoring/EnergyGraph.hh>
#include <utility/vector0.hh>
#include <utility/excn/Exceptions.hh>
//#include <boost/pool/poolfwd.hpp>
using namespace core;
using namespace protocols;
using namespace ObjexxFCL;
using namespace basic::options;
using namespace basic::options::OptionKeys;
using utility::vector1;
using std::string;
using io::pdb::dump_pdb;
static THREAD_LOCAL basic::Tracer TR( "apps.pilot.chrisk/pep_prep" );
//parse cst line as: name1 res1 x y z x0 sd tol
struct pep_coord_cst {
std::string atom_name;
int pep_pos;
Real x;
Real y;
Real z;
Real x0;
Real sd;
Real tol;
};
vector1< pep_coord_cst > pep_coord_csts;
//print homol_csts data
void
print_pep_csts(
vector1< Vector > pep_cst_all_vects,
vector1< Real > pep_cst_all_tols,
vector1< Real > pep_cst_all_sds,
vector1< Size > n_pep_cs,
vector1< Size > pep_cst_all_indices,
vector1< std::string > pep_cst_all_atom_names
)
{
Size min_cas_for_cst( 3 );
//Real min_tol_for_cst( 1.0 ); // unused ~Labonte
Real max_pep_cs( *( std::max_element( n_pep_cs.begin(), n_pep_cs.end() ) ) );
std::string cst_file_name_str( option[ out::file::o ]+".cst" );
char const *cst_file_name = cst_file_name_str.c_str();
std::fstream cst_file( cst_file_name, std::ios::out );
for ( Size i = 1; i <= pep_cst_all_vects.size(); ++i ) {
if ( n_pep_cs[ i ] < min_cas_for_cst && option[ pepspec::p_homol_csts ].user() ) continue;
Real this_tol( pep_cst_all_tols[ i ] + pep_cst_all_tols[ i ] * ( 1.0 - std::pow( ( n_pep_cs[ i ] / max_pep_cs ), 1.0 / 3.0 ) ) );
Vector pep_cst_vect( pep_cst_all_vects[ i ] );
int pep_pos( pep_cst_all_indices[ i ] );
//Real pep_cst_tol( pep_cst_all_tols[ i ] ); // unused ~Labonte
// if( pep_cst_tol < min_tol_for_cst ) pep_cst_tol = min_tol_for_cst;
cst_file << pep_cst_all_atom_names[ i ] + "\t" + string_of( pep_pos ) + "\t" + string_of( pep_cst_vect.x() ) + "\t" + string_of( pep_cst_vect.y() ) + "\t" + string_of( pep_cst_vect.z() ) + "\t0.0\t" + string_of( pep_cst_all_sds[ i ] ) + "\t" + string_of( this_tol ) + "\n";
}
}
void
set_pep_cst(
pose::Pose & pose,
Size pep_anchor,
pep_coord_cst pep_cst
)
{
using namespace core::scoring::constraints;
using namespace core::chemical;
Size seqpos( pep_cst.pep_pos + pep_anchor );
Size prot_anchor( 2 );
Vector pep_cst_vector;
pep_cst_vector.x( pep_cst.x );
pep_cst_vector.y( pep_cst.y );
pep_cst_vector.z( pep_cst.z );
ConstraintCOP this_cst( ConstraintOP( new CoordinateConstraint( id::AtomID( pose.residue( seqpos ).atom_index( pep_cst.atom_name ), seqpos ), id::AtomID( pose.residue( prot_anchor ).atom_index( "CA" ), prot_anchor ), pep_cst_vector, core::scoring::func::FuncOP( new core::scoring::func::FlatHarmonicFunc( pep_cst.x0, pep_cst.sd, pep_cst.tol ) ) ) ) );
pose.add_constraint( this_cst );
}
/// @details This function will make a sequence mutation while trying to preserve the variants
void
make_sequence_change(
Size const seqpos,
chemical::AA const & new_aa,
pose::Pose & pose
)
{
conformation::Residue const & current_rsd( pose.residue( seqpos ) );
if ( current_rsd.aa() == new_aa ) return; // already done
chemical::ResidueTypeSetCOP rsd_type_set( pose.residue_type_set_for_pose( current_rsd.type().mode() ) );
chemical::ResidueTypeCOP rsd_type( rsd_type_set->get_representative_type_aa( new_aa, current_rsd.type().variant_types() ) );
if ( ! rsd_type ) {
utility_exit_with_message( "make_sequence_change failed: new_aa= "+chemical::name_from_aa(new_aa)+" -- no residue types found. " );
}
conformation::ResidueOP new_rsd( conformation::ResidueFactory::create_residue( *rsd_type, current_rsd, pose.conformation() ) );
pose.replace_residue( seqpos, *new_rsd, false );
}
bool
has_clash(
pose::Pose pose,
vector1< bool > check_seqpos,
scoring::ScoreFunctionOP const & scorefxn,
Real const clash_threshold,
bool print_clash
)
{
using namespace scoring;
using namespace chemical;
( *scorefxn )( pose );
// cached energies object
Energies & energies( pose.energies() );
// the neighbor/energy links
EnergyGraph & energy_graph( energies.energy_graph() );
bool is_clash( false );
for ( Size seqpos = 1; seqpos <= pose.size(); ++seqpos ) {
if ( !check_seqpos[ seqpos ] ) continue;
// search upstream
for ( utility::graph::Graph::EdgeListIter
iru = energy_graph.get_node( seqpos )->lower_edge_list_begin(),
irue = energy_graph.get_node( seqpos )->lower_edge_list_end();
iru != irue; ++iru ) {
EnergyEdge * edge( static_cast< EnergyEdge *> (*iru) );
Size const j( edge->get_first_node_ind() );
// the pair energies cached in the link
EnergyMap const & emap( edge->fill_energy_map());
Real const clash( emap[ fa_rep ] );
if ( clash > clash_threshold ) {
if ( print_clash ) TR<< "fa_rep: " << string_of( clash ) << " at " << pose.residue( j ).name1() << string_of( j ) << "-" << pose.residue( seqpos ).name1() << string_of( seqpos ) << std::endl;
is_clash = true;
return is_clash;
}
}
// and downstream
for ( utility::graph::Graph::EdgeListIter
iru = energy_graph.get_node( seqpos )->upper_edge_list_begin(),
irue = energy_graph.get_node( seqpos )->upper_edge_list_end();
iru != irue; ++iru ) {
EnergyEdge * edge( static_cast< EnergyEdge *> (*iru) );
Size const j( edge->get_second_node_ind() );
// the pair energies cached in the link
EnergyMap const & emap( edge->fill_energy_map());
Real const clash( emap[ fa_rep ] );
if ( clash > clash_threshold ) {
if ( print_clash ) TR<< "fa_rep: " << string_of( clash ) << " at " << pose.residue( j ).name1() << string_of( j ) << "-" << pose.residue( seqpos ).name1() << string_of( seqpos ) << std::endl;
is_clash = true;
return is_clash;
}
}
}
return is_clash;
}
std::string
pep_rmsd_analysis(
pose::Pose pose,
Size prot_begin,
Size prot_end,
Size pep_begin,
Size pep_anchor,
Size pep_end
)
{
pose::Pose ref_pose;
std::string ref_name( option[ in::file::native ]() );
import_pose::pose_from_file( ref_pose, ref_name , core::import_pose::PDB_file);
Size ref_pep_anchor( pep_anchor );
if ( option[ pepspec::native_pep_anchor ].user() ) {
Size ref_pep_anchor_in = option[ pepspec::native_pep_anchor ];
std::string ref_pep_chain_in( option[ pepspec::pep_chain ] );
if ( option[ pepspec::native_pep_chain ].user() ) ref_pep_chain_in = option[ pepspec::native_pep_chain ];
ref_pep_anchor = ref_pose.pdb_info()->pdb2pose( ref_pep_chain_in[0], ref_pep_anchor_in );
}
Size ref_pep_chain( ref_pose.chain( ref_pep_anchor ) );
Size ref_pep_begin( ref_pose.conformation().chain_begin( ref_pep_chain ) );
Size ref_pep_end( ref_pose.conformation().chain_end( ref_pep_chain ) );
Size ref_prot_chain = 0;
for ( Size i = 1; i <= ref_pose.conformation().num_chains(); ++i ) {
if ( i == ref_pep_chain ) continue;
if ( !( ref_pose.residue( ref_pose.conformation().chain_begin( i ) ).is_protein() ) ) continue;
else {
ref_prot_chain = i;
break;
}
}
Size ref_prot_begin( ref_pose.conformation().chain_begin( ref_prot_chain ) );
//Size ref_prot_end( ref_pose.conformation().chain_end( ref_prot_chain ) ); // unused ~Labonte
//Size ref_prot_anchor( ref_prot_begin ); // unused ~Labonte
Size pep_nterm( pep_anchor - pep_begin );
Size ref_pep_nterm( ref_pep_anchor - ref_pep_begin );
Size pep_cterm( pep_end - pep_anchor );
Size ref_pep_cterm( ref_pep_end - ref_pep_anchor );
Size nterm( pep_nterm );
Size cterm( pep_cterm );
if ( pep_nterm < ref_pep_nterm ) ref_pep_begin += ref_pep_nterm - pep_nterm;
else if ( pep_nterm > ref_pep_nterm ) {
pep_begin += pep_nterm - ref_pep_nterm;
nterm = ref_pep_nterm;
}
if ( pep_cterm < ref_pep_cterm ) ref_pep_end -= ref_pep_cterm - pep_cterm;
else if ( pep_cterm > ref_pep_cterm ) {
pep_end -= pep_cterm - ref_pep_cterm;
cterm = ref_pep_cterm;
}
//superpose if needed
if ( option[ pepspec::native_align ] ) {
id::AtomID_Map< id::AtomID > atom_map;
pose::initialize_atomid_map( atom_map, pose, id::BOGUS_ATOM_ID );
for ( Size i = prot_begin; i <= prot_end; ++i ) {
id::AtomID const id1( pose.residue( i ).atom_index( "CA" ), i );
id::AtomID const id2( ref_pose.residue( i + static_cast< int >( ref_prot_begin ) - static_cast< int >( prot_begin ) ).atom_index( "CA" ), i + static_cast< int >( ref_prot_begin ) - static_cast< int >( prot_begin ) );
atom_map[ id1 ] = id2;
}
core::scoring::ScoreFunctionOP full_scorefxn( core::scoring::get_score_function() );
core::scoring::superimpose_pose( pose, ref_pose, atom_map );
}
Real sd( 0.0 );
std::string rmsd_analysis( "" );
Size natoms( 0 );
for ( Size i_seq = 0; i_seq <= nterm + cterm; ++i_seq ) {
Size ref_pep_seqpos = ref_pep_begin + i_seq;
Size pep_seqpos = pep_begin + i_seq;
// if( pose.residue( pep_seqpos ).natoms() != ref_pose.residue( ref_pep_seqpos ).natoms() ) utility_exit_with_message( "natoms mismatch for fa_rmsd\n" );
for ( Size atomno = 1; atomno <= pose.residue( pep_seqpos ).natoms(); ++atomno ) {
sd += ref_pose.residue( ref_pep_seqpos ).xyz( atomno ).distance_squared( pose.residue( pep_seqpos ).xyz( atomno ) );
++natoms;
}
}
Real total_rmsd = std::sqrt( sd / natoms );
rmsd_analysis += "fa_rmsd:\t" + string_of( total_rmsd ) + "\t";
return rmsd_analysis;
}
Real
average(
vector1< Real > real_vec
)
{
Real avg( 0 );
for ( Size i = 1; i <= real_vec.size(); ++i ) {
avg += real_vec[ i ] / real_vec.size();
}
return avg;
}
//function for getting array of radian angles ready for averaging
vector1< Real >
shift_angles(
vector1< Real > & angles
)
{
const Real pi = numeric::NumericTraits<Real>::pi();
Size n_angles( angles.size() );
vector1< Real > pos_angles;
vector1< Real > neg_angles;
for ( Size i = 1; i <= n_angles; ++i ) {
if ( angles[ i ] >=0 ) pos_angles.push_back( angles[ i ] );
else neg_angles.push_back( angles[ i ] );
}
Size n_pos_angles( pos_angles.size() );
Size n_neg_angles( neg_angles.size() );
if ( n_pos_angles >= n_neg_angles ) {
Real avg_pos_angle( average( pos_angles ) );
for ( Size i = 1; i <= n_angles; ++i ) {
if ( angles[ i ] < 0 && fabs( angles[ i ] - avg_pos_angle ) > pi ) angles[ i ] += ( 2 * pi );
}
} else {
Real avg_neg_angle( average( neg_angles ) );
for ( Size i = 1; i <= n_angles; ++i ) {
if ( angles[ i ] >= 0 && fabs( angles[ i ] - avg_neg_angle ) > pi ) angles[ i ] -= ( 2 * pi );
}
}
return angles;
}
void
run_pep_prep()
{
using namespace pose;
using namespace chemical;
using namespace conformation;
using namespace scoring;
using namespace optimization;
using namespace kinematics;
using namespace sequence;
using namespace protocols::moves;
using namespace id;
using namespace protocols::frags;
using numeric::conversions::radians;
using numeric::conversions::degrees;
typedef numeric::xyzVector< Real > Vector; // DOUBLE!
typedef numeric::xyzMatrix< Real > Matrix; // DOUBLE!
std::string pdb_out_list_filename_str( option[ out::file::o ]+".pdblist" );
char const *pdb_out_list_filename = pdb_out_list_filename_str.c_str();
std::fstream pdb_out_list_file( pdb_out_list_filename, std::ios::out );
/*
std::string cst_list_file_name_str( option[ out::file::o ]+".cstlist" );
char const *cst_list_file_name = cst_list_file_name_str.c_str();
std::fstream cst_list_file( cst_list_file_name, std::ios::out );
*/
std::string out_nametag( "data" );
if ( option[ out::file::o ].user() ) out_nametag = option[ out::file::o ];
std::string out_file_name_str( out_nametag + ".spec" );
char const *out_file_name = out_file_name_str.c_str();
std::fstream out_file( out_file_name, std::ios::out );
vector1< string > ref_pdbs;
vector1< string > ref_pep_chains;
vector1< string > ref_pep_anchors_int;
if ( option[ pepspec::ref_pdb_list ].user() ) {
std::string ref_filename( option[ pepspec::ref_pdb_list ] );
std::ifstream ref_file( ref_filename.c_str() );
std::string line;
std::string word;
while ( !getline( ref_file, line ).eof() ) {
std::istringstream line_parse( line );
for ( Size ii = 1; !getline( line_parse, word, '\t' ).eof(); ++ii ) {
if ( ii == 1 ) ref_pdbs.push_back( word );
else if ( ii == 2 ) ref_pep_chains.push_back( word );
else utility_exit_with_message( "ref_pdb_list has too many args @ line \"" + line + "\"\n" );
}
getline( line_parse, word );
ref_pep_anchors_int.push_back( word );
}
} else utility_exit_with_message( "ref_pdb_list not defined!\n" );
if ( ref_pdbs.size() < 1 ) utility_exit_with_message( "no ref pdbs loaded!\n" );
if ( ref_pep_chains.size() < 1 ) utility_exit_with_message( "no ref chains loaded!\n" );
Size n_ref_poses( ref_pdbs.size() );
vector1< Pose > ref_poses( n_ref_poses );
vector1< Size > ref_pep_anchors( n_ref_poses );
vector1< Vector > jump_trans_vector( n_ref_poses );
vector1< Matrix > jump_rot_matrix( n_ref_poses );
vector1< Real > jump_bond_angle( n_ref_poses );
vector1< Real > jump_tor1_angle( n_ref_poses );
vector1< Real > jump_tor2_angle( n_ref_poses );
std::string prot_anchor_stub1( "N" );
std::string prot_anchor_stub2( "CA" );
std::string prot_anchor_stub3( "C" );
std::string pep_anchor_stub1( "CB" );
std::string pep_anchor_stub2( "CA" );
std::string pep_anchor_stub3( "N" );
/////////////////////////////////////////////
vector1< std::string > pdb_filenames;
if ( option[ pepspec::pdb_list ].user() ) {
std::string pdb_list_filename( option[ pepspec::pdb_list ] );
std::ifstream pdb_list_data( pdb_list_filename.c_str() );
if ( !pdb_list_data.good() ) {
utility_exit_with_message( "Unable to open file: " + pdb_list_filename + '\n' );
}
std::string pdb_list_line;
while ( !getline( pdb_list_data, pdb_list_line, '\n' ).eof() ) {
std::string this_filename( pdb_list_line );
pdb_filenames.push_back( this_filename );
}
} else {
pdb_filenames.push_back( basic::options::start_file() );
}
Pose pose;
import_pose::pose_from_file( pose, pdb_filenames[ 1 ] , core::import_pose::PDB_file);
ResidueTypeSet const & rsd_set( *pose.residue_type_set_for_pose() );
//Size const nres( pose.size() ); // unused ~Labonte
Size prot_chain = 0;
for ( Size i = 1; i <= pose.conformation().num_chains(); ++i ) {
if ( !( pose.residue( pose.conformation().chain_begin( i ) ).is_protein() ) ) continue;
else {
prot_chain = i;
break;
}
}
if ( option[ pepspec::remove_input_bb ] ) {
pose = *(pose.split_by_chain( prot_chain ));
}
Size prot_begin( pose.conformation().chain_begin( prot_chain ) );
Size prot_end( pose.conformation().chain_end( prot_chain ) );
Size prot_anchor( prot_begin + 1 );
// create a simple foldtree of the right size
FoldTree f( pose.size() );
//gen fold tree
// if( prot_begin != 1 ) f.new_jump( prot_anchor, 1, 1 );
// if( prot_end != pose.size() ) f.new_jump( prot_anchor, prot_end + 1, prot_end );
core::scoring::ScoreFunctionOP scorefxn( get_score_function() );
core::scoring::ScoreFunctionOP soft_scorefxn( ScoreFunctionFactory::create_score_function( option[ pepspec::soft_wts ] ) );
//for each desired anchor-docked protein
Size n_peptides( option[ pepspec::n_peptides ] );
int pose_index( 0 );
if ( option[ pepspec::run_sequential ] ) n_peptides = pdb_filenames.size();
for ( Size peptide_loop = 1; peptide_loop <= n_peptides; ++peptide_loop ) {
if ( option[ pepspec::run_sequential ] ) ++pose_index;
else pose_index = static_cast< int >( numeric::random::rg().uniform() * pdb_filenames.size() + 1 );
std::string pdb_filename( pdb_filenames[ pose_index ] );
TR<<"Initializing "<< "prep_" + string_of( peptide_loop ) + ".pdb with " + pdb_filename << std::endl;
import_pose::pose_from_file( pose, pdb_filename , core::import_pose::PDB_file);
// set the new foldtree in the pose
pose.fold_tree( f );
//prepack?
if ( !option[ pepspec::no_prepack_prot ] ) {
( *soft_scorefxn )( pose );
pack::task::PackerTaskOP prepack_task( pack::task::TaskFactory::create_packer_task( pose ));
prepack_task->initialize_from_command_line().restrict_to_repacking().or_include_current( true );
protocols::simple_moves::PackRotamersMoverOP prepack_mover( new protocols::simple_moves::PackRotamersMover( soft_scorefxn, prepack_task, 1 ) );
prepack_mover->apply( pose );
using pack::task::operation::TaskOperationCOP;
pack::task::TaskFactoryOP prepack_task_factory( new pack::task::TaskFactory );
prepack_task_factory->push_back( TaskOperationCOP( new pack::task::operation::InitializeFromCommandline() ) );
prepack_task_factory->push_back( TaskOperationCOP( new pack::task::operation::IncludeCurrent() ) );
prepack_task_factory->push_back( TaskOperationCOP( new pack::task::operation::RestrictToRepacking() ) );
protocols::simple_moves::RotamerTrialsMoverOP prepack_rottrial( new protocols::simple_moves::RotamerTrialsMover( soft_scorefxn, prepack_task_factory ) );
prepack_rottrial->apply( pose );
kinematics::MoveMapOP mm_prepack( new kinematics::MoveMap );
mm_prepack->set_chi( true );
protocols::simple_moves::MinMoverOP prepack_min_mover( new protocols::simple_moves::MinMover( mm_prepack, scorefxn, "lbfgs_armijo_nonmonotone", 0.001, true ) );
prepack_min_mover->apply( pose );
dump_pdb( pose, pdb_filename + ".prepack" );
}
( *scorefxn )( pose );
Real prot_score( pose.energies().total_energies().dot( scorefxn->weights() ) );
//align to other pre-aligned struct of same seq
if ( option[ pepspec::prep_align_prot_to ].user() ) {
std::string align_name( option[ pepspec::prep_align_prot_to ] );
Pose align_pose;
import_pose::pose_from_file( align_pose, align_name , core::import_pose::PDB_file);
id::AtomID_Map< id::AtomID > atom_map;
pose::initialize_atomid_map( atom_map, pose, id::BOGUS_ATOM_ID );
for ( Size i = prot_begin; i <= prot_end; ++i ) {
id::AtomID const id1( pose.residue( i ).atom_index( "CA" ), i );
id::AtomID const id2( align_pose.residue( i ).atom_index( "CA" ), i );
atom_map[ id1 ] = id2;
}
superimpose_pose( pose, align_pose, atom_map );
}
// add anchor in random pos
std::string const anchor_type( option[ pepspec::anchor_type ] );
ResidueOP pep_anchor_res( ResidueFactory::create_residue( rsd_set.name_map( anchor_type ) ) );
pose.append_residue_by_jump( *pep_anchor_res, prot_anchor, prot_anchor_stub2, pep_anchor_stub1, true );
Size pep_anchor( pose.size() );
//Size pep_chain( pose.chain( pep_anchor ) ); // unused ~Labonte
Size pep_jump( pose.num_jump() );
Pose start_pose( pose );
/*
if( anchor_type == "PRO" ){
pep_anchor_stub2 = "C";
pep_anchor_stub3 = "O";
}
*/
// FoldTree f_jump( pose.size() );
FoldTree f_jump( pose.fold_tree() );
FoldTree f_orient( pose.size() );
f_orient.new_chemical_bond( prot_anchor, pep_anchor, prot_anchor_stub2, pep_anchor_stub1 , prot_end );
/*
f_jump.new_jump( prot_anchor, pep_anchor, prot_end );
if( prot_end != pose.size() - 1 ){
f_jump.new_jump( prot_anchor, prot_end + 1, prot_end );
f_orient.new_jump( prot_anchor, prot_end + 1, prot_end );
}
f_jump.reorder( prot_anchor );
f_jump.set_jump_atoms( pep_jump, prot_anchor_stub2, pep_anchor_stub1 );
*/
//chrisk 6/28/201
/*2
if( prot_chain < pep_chain ){
pep_jump = f_jump.new_jump( prot_anchor, pep_anchor, pep_anchor - 1 );
f_jump.set_jump_atoms( pep_jump, prot_anchor_stub2, pep_anchor_stub1 );
# if( pep_anchor != pose.size() ) f_jump.new_jump( prot_anchor, pep_anchor + 1, pep_anchor );
if( prot_end + 1 != pep_anchor ) f_jump.new_jump( prot_anchor, prot_end + 1, prot_end );
}
else{
pep_jump = f_jump.new_jump( pep_anchor, prot_anchor, prot_begin - 1 );
f_jump.set_jump_atoms( pep_jump, pep_anchor_stub1, prot_anchor_stub2 );
# if( prot_end != pose.size() ) f_jump.new_jump( prot_anchor, prot_end + 1, prot_end );
if( pep_anchor + 1 != prot_begin ) f_jump.new_jump( pep_anchor, pep_anchor + 1, pep_anchor );
}
*/
f_jump.reorder( prot_anchor );
//homol_csts
//calc vect sum, then normalize to avgs, then reiter over refs to get max distance
//pep_ca_vects is peptides< seqpos< pep_pos, Vector > >
vector1< vector1< std::pair < int, Vector > > > pep_ca_vects;
vector1< vector1< std::pair < int, Vector > > > pep_cb_vects;
int ref_pep_pos_min( 0 );
int ref_pep_pos_max( 0 );
/////////////////////////////////////////////////////////////////////////////////////////
// copy anchor xyz coords from ref pdbs to pose and calc/store kinematic orientation
bool pep_anchor_is_nterm( false );
for ( Size i = 1; i <= n_ref_poses; ++i ) {
//START CUT OUT, put this part of the ref prot loop outside the gen docked target loop
//load ref pdb name and chain, anchor data
std::string ref_input_name( ref_pdbs[ i ] );
std::string const ref_pep_chain_in( ref_pep_chains[ i ] );
std::istringstream ref_pep_anchor_in( ref_pep_anchors_int[ i ] );
int ref_pep_anchor_int;
ref_pep_anchor_in >> ref_pep_anchor_int;
if ( peptide_loop == 1 ) TR << "Loading " << ref_input_name << ": pep anchor @ chain " << ref_pep_chain_in << " seqpos " << string_of( ref_pep_anchor_int ) << std::endl;
//load ref pdb
Pose ref_pose;
import_pose::pose_from_file( ref_pose, ref_input_name , core::import_pose::PDB_file);
Size const ref_pep_anchor( ref_pose.pdb_info()->pdb2pose( ref_pep_chain_in[0], ref_pep_anchor_int ) );
if ( ref_pep_anchor == 0 ) utility_exit_with_message( "ERROR: Residue " + string_of( ref_pep_anchor_int ) + " not found in " + ref_input_name + "\n" );
//if gly, just change to ala, orient and calc data, then change back
//can we just use one of the Halphas?
//if( ref_pose.residue( ref_pep_anchor ).name3() == "GLY" ) utility_exit_with_message( "Cannot yet handle GLY anchors\n" );
if ( ref_pose.residue( ref_pep_anchor ).name3() == "GLY" ) {
make_sequence_change( ref_pep_anchor, chemical::aa_ala, ref_pose );
}
//store ref pose, anchor
ref_poses[ i ] = ref_pose;
ref_pep_anchors[ i ] = ref_pep_anchor;
Size const ref_pep_chain( ref_pose.chain( ref_pep_anchor ) );
Size ref_pep_begin( ref_pose.conformation().chain_begin( ref_pose.chain( ref_pep_anchor ) ) );
Size ref_pep_end( ref_pose.conformation().chain_end( ref_pose.chain( ref_pep_anchor ) ) );
//set ref prot chain = first non-peptide protein chain in pose
Size ref_prot_chain = 0;
for ( Size ii = 1; ii <= ref_pose.conformation().num_chains(); ++ii ) {
if ( ii == ref_pep_chain ) continue;
if ( !( ref_pose.residue( ref_pose.conformation().chain_begin( ii ) ).is_protein() ) ) continue;
else {
ref_prot_chain = ii;
break;
}
}
Size ref_prot_begin( ref_pose.conformation().chain_begin( ref_prot_chain ) );
//sequence alignment of ref prot and target?
if ( option[ pepspec::seq_align ] ) {
utility::file::FileName blosum62( "/home/cking/blosum/BLOSUM62" );
ScoringSchemeOP ss( new MatrixScoringScheme( -11, -1, blosum62 ) );
NWAligner nw_aligner;
SequenceOP seq1( new Sequence( ref_pose.chain_sequence( ref_prot_chain ), "ref", ref_prot_begin ) );
SequenceOP seq2( new Sequence( pose.chain_sequence( prot_chain ), "target", prot_begin ) );
SequenceAlignment global_align = nw_aligner.align( seq1, seq2, ss );
SequenceMapping seq_map( global_align.sequence_mapping( 1, 2 ) );
//seq_map.show( TR );
vector1< Size > seq_align( seq_map.mapping() );
id::AtomID_Map< id::AtomID > atom_map;
pose::initialize_atomid_map( atom_map, pose, id::BOGUS_ATOM_ID );
Real total_rmsd( 0 );
Size npos( 0 );
for ( Size ii = 1; ii <= seq_align.size(); ++ii ) {
if ( seq_align[ ii ] == 0 ) continue;
id::AtomID const id1( ref_pose.residue( ii ).atom_index( "CA" ), ii );
id::AtomID const id2( pose.residue( seq_align[ ii ] ).atom_index( "CA" ), seq_align[ ii ] );
atom_map[ id1 ] = id2;
total_rmsd += ref_pose.residue( ii ).xyz( "CA" ).distance_squared( pose.residue( seq_align[ ii ] ).xyz( "CA" ) );
++npos;
}
total_rmsd = std::sqrt( total_rmsd / npos );
TR << string_of( total_rmsd ) + " Ca RMSD over " + string_of( npos ) + " atoms\n";
if ( npos < pose.size() / 2 ) utility_exit_with_message( "Alignment falied at " + ref_input_name + "\n" );
//superimpose ref, target with atom map from seq alignment
superimpose_pose( ref_pose, pose, atom_map );
}
//store calpha vectors for csts
if ( option[ pepspec::homol_csts ].user() && peptide_loop == 1 ) {
for ( Size i_mut = ref_pep_begin; i_mut <= ref_pep_end; ++i_mut ) {
if ( i_mut == ref_pep_anchor ) continue;
make_sequence_change( i_mut, chemical::aa_ala, ref_pose );
}
vector1< std::pair< int, Vector > > pep_ca_vect;
vector1< std::pair< int, Vector > > pep_cb_vect;
for ( Size ii = ref_pep_begin; ii <= ref_pep_end; ++ii ) {
int ref_pep_pos( ii - ref_pep_anchor );
if ( ref_pep_pos < ref_pep_pos_min ) ref_pep_pos_min = ref_pep_pos;
if ( ref_pep_pos > ref_pep_pos_max ) ref_pep_pos_max = ref_pep_pos;
Vector pep_ca_coord( ref_pose.residue( ii ).xyz( "CA" ) );
Vector pep_cb_coord( ref_pose.residue( ii ).xyz( "CB" ) );
std::pair< int, Vector > pep_ca_pair( ref_pep_pos, pep_ca_coord );
std::pair< int, Vector > pep_cb_pair( ref_pep_pos, pep_cb_coord );
pep_ca_vect.push_back( pep_ca_pair );
pep_cb_vect.push_back( pep_cb_pair );
}
//store ca, cb vecotrs for constraints
pep_ca_vects.push_back( pep_ca_vect );
pep_cb_vects.push_back( pep_cb_vect );
}
//END CUT OUT
/////////////////////////////////////////////////////////////////////////////////////
//set target anchor coords to those from ref anchor and store translations, rotations
//check for noisy stub conformations due to no restraint at termini
if ( ref_pose.conformation().chain_begin( ref_pep_chain ) == ref_pep_anchor ) {
//check if previous refs were stored w/ nterm stub
if ( pep_anchor_is_nterm == false && i != 1 ) utility_exit_with_message( "nterm anchor must be first\n" );
pep_anchor_is_nterm = true;
// pep_anchor_stub2 = "C";
// pep_anchor_stub3 = "O";
pep_anchor_stub3 = "C";
}
if ( ref_pose.conformation().chain_end( ref_pep_chain ) == ref_pep_anchor && pep_anchor_is_nterm == true ) utility_exit_with_message( "cannot have nterm and cterm ref pep anchors\n" );
//TODO: WTF is this?
if ( pose.residue( pep_anchor ).name3() != "PRO" && ref_pose.residue( ref_pep_anchor ).name3() == "PRO" ) utility_exit_with_message( "cannot have PRO ref anchor for non-PRO anchor, need coords for H!\n" );
if ( pose.residue( pep_anchor ).name3() != "PRO" && !pep_anchor_is_nterm ) pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "H" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "H" ), ref_pep_anchor ) ) );
pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "N" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "N" ), ref_pep_anchor ) ) );
pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "CA" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "CA" ), ref_pep_anchor ) ) );
pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "CB" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "CB" ), ref_pep_anchor ) ) );
pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "C" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "C" ), ref_pep_anchor ) ) );
pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "HA" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "HA" ), ref_pep_anchor ) ) );
pose.set_xyz( AtomID( pose.residue( pep_anchor ).atom_index( "O" ), pep_anchor ), ref_pose.xyz( AtomID( ref_pose.residue( ref_pep_anchor ).atom_index( "O" ), ref_pep_anchor ) ) );
pose.fold_tree( f_jump );
Residue rsd1( pose.residue( prot_anchor ) );
Residue rsd2( pose.residue( pep_anchor ) );
StubID upstubid( AtomID( rsd1.atom_index( prot_anchor_stub1 ), prot_anchor ) ,
AtomID( rsd1.atom_index( prot_anchor_stub2 ), prot_anchor ) ,
AtomID( rsd1.atom_index( prot_anchor_stub3 ), prot_anchor ) ) ;
StubID downstubid( AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub3 ), pep_anchor ) ) ;
RT const rt( pose.conformation().get_stub_transform( upstubid, downstubid ) );
jump_trans_vector[i] = rt.get_translation();
jump_rot_matrix[i] = rt.get_rotation();
if ( peptide_loop == 1 ) TR << "RB translation: x, y, z: " << jump_trans_vector[i].x() << ", " << jump_trans_vector[i].y() << ", " << jump_trans_vector[i].z() << std::endl;
///////////////////////
pose.fold_tree( f_orient );
jump_bond_angle[i] = pose.conformation().bond_angle( AtomID( rsd1.atom_index( prot_anchor_stub2 ), prot_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) );
jump_tor1_angle[i] = pose.conformation().torsion_angle( AtomID( rsd1.atom_index( prot_anchor_stub2 ), prot_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub3 ), pep_anchor ) );
jump_tor2_angle[i] = pose.conformation().torsion_angle( AtomID( rsd1.atom_index( prot_anchor_stub1 ), prot_anchor ) ,
AtomID( rsd1.atom_index( prot_anchor_stub2 ), prot_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) );
if ( peptide_loop == 1 ) TR << "RB rotation: bond, tor1, tor2: " << degrees( jump_bond_angle[i] ) << ", " << degrees( jump_tor1_angle[i] ) << ", " << degrees( jump_tor2_angle[i] ) << std::endl;
}
//homol_csts
Size ref_pep_nres_max( ( -1 * ref_pep_pos_min ) + 1 + ref_pep_pos_max );
vector1< Vector > pep_cst_ca_vects( ref_pep_nres_max, Vector( 0.0, 0.0, 0.0 ) );
vector1< Vector > pep_cst_cb_vects( ref_pep_nres_max, Vector( 0.0, 0.0, 0.0 ) );
vector1< Real > pep_cst_ca_tols( ref_pep_nres_max, 0.0 );
vector1< Real > pep_cst_cb_tols( ref_pep_nres_max, 0.0 );
vector1< Real > pep_cst_ca_sds( ref_pep_nres_max, 0.0 );
vector1< Real > pep_cst_cb_sds( ref_pep_nres_max, 0.0 );
vector1< Size > pep_cst_ca_indices( ref_pep_nres_max, 0 );
vector1< Size > pep_cst_cb_indices( ref_pep_nres_max, 0 );
if ( option[ pepspec::homol_csts ].user() ) {
vector1< Size > n_pep_cas( ref_pep_nres_max, 0 );
//sum pep_ca_vects -> pep_cst_ca_vects and n_pep_cas
for ( Size i = 1; i <= pep_ca_vects.size(); ++i ) {
vector1< std::pair< int, Vector > > pep_ca_vect( pep_ca_vects[ i ] );
vector1< std::pair< int, Vector > > pep_cb_vect( pep_cb_vects[ i ] );
for ( Size ii = 1; ii <= pep_ca_vect.size(); ++ii ) {
int pep_pos( pep_ca_vect[ ii ].first );
Vector pep_ca_coord( pep_ca_vect[ ii ].second );
Vector pep_cb_coord( pep_cb_vect[ ii ].second );
Size i_pep( pep_pos - ref_pep_pos_min + 1 );
++n_pep_cas[ i_pep ];
pep_cst_ca_vects[ i_pep ] += pep_ca_coord;
pep_cst_cb_vects[ i_pep ] += pep_cb_coord;
}
}
//normalize pep_cst_ca_vects -> avgs
for ( Size i = 1; i <= pep_cst_ca_vects.size(); ++i ) {
pep_cst_ca_vects[ i ] = pep_cst_ca_vects[ i ] / n_pep_cas[ i ];
pep_cst_cb_vects[ i ] = pep_cst_cb_vects[ i ] / n_pep_cas[ i ];
}
//find max dists -> tols
for ( Size i = 1; i <= pep_ca_vects.size(); ++i ) {
vector1< std::pair< int, Vector > > pep_ca_vect( pep_ca_vects[ i ] );
vector1< std::pair< int, Vector > > pep_cb_vect( pep_cb_vects[ i ] );
for ( Size ii = 1; ii <= pep_ca_vect.size(); ++ii ) {
int pep_pos( pep_ca_vect[ ii ].first );
Vector pep_ca_coord( pep_ca_vect[ ii ].second );
Vector pep_cb_coord( pep_cb_vect[ ii ].second );
Size i_pep( pep_pos - ref_pep_pos_min + 1 );
Real dist_to_ca_avg( pep_ca_coord.distance( pep_cst_ca_vects[ i_pep ] ) );
Real dist_to_cb_avg( pep_cb_coord.distance( pep_cst_cb_vects[ i_pep ] ) );
pep_cst_ca_sds[ i_pep ] += ( dist_to_ca_avg * dist_to_ca_avg );
pep_cst_cb_sds[ i_pep ] += ( dist_to_cb_avg * dist_to_cb_avg );
if ( dist_to_ca_avg > pep_cst_ca_tols[ i_pep ] ) pep_cst_ca_tols[ i_pep ] = dist_to_ca_avg;
if ( dist_to_cb_avg > pep_cst_cb_tols[ i_pep ] ) pep_cst_cb_tols[ i_pep ] = dist_to_cb_avg;
}
}
for ( Size i = 1; i <= ref_pep_nres_max; ++i ) {
if ( n_pep_cas[ i ] > 1 ) pep_cst_ca_sds[ i ] = std::sqrt( pep_cst_ca_sds[ i ] / ( n_pep_cas[ i ] - 1 ) );
else pep_cst_ca_sds[ i ] = 100;
if ( n_pep_cas[ i ] > 1 ) pep_cst_cb_sds[ i ] = std::sqrt( pep_cst_cb_sds[ i ] / ( n_pep_cas[ i ] - 1 ) );
else pep_cst_cb_sds[ i ] = 100;
pep_cst_ca_indices[ i ] = ref_pep_pos_min + i - 1;
pep_cst_cb_indices[ i ] = ref_pep_pos_min + i - 1;
}
//combine ca and cb data, build atom name vector
vector1< Vector > pep_cst_all_vects( pep_cst_ca_vects );
vector1< Real > pep_cst_all_tols( pep_cst_ca_tols );
vector1< Real > pep_cst_all_sds( pep_cst_ca_sds );
vector1< std::string > pep_cst_all_atom_names( ref_pep_nres_max, "CA" );
vector1< Size > pep_cst_all_indices( pep_cst_ca_indices );
vector1< Size > n_pep_cs( n_pep_cas );
/*
for( Size i = 1; i <= ref_pep_nres_max; ++i ){
pep_cst_all_vects.push_back( pep_cst_cb_vects[ i ] );
pep_cst_all_tols.push_back( pep_cst_cb_tols[ i ] );
pep_cst_all_sds.push_back( pep_cst_cb_sds[ i ] );
pep_cst_all_atom_names.push_back( "CB" );
pep_cst_all_indices.push_back( pep_cst_cb_indices[ i ] );
n_pep_cs.push_back( n_pep_cas[ i ] );
}
*/
//now have pep_cst_ca_vects and pep_cst_ca_tols
if ( peptide_loop == 1 ) print_pep_csts( pep_cst_all_vects, pep_cst_all_tols, pep_cst_all_sds, n_pep_cs, pep_cst_all_indices, pep_cst_all_atom_names );
}
TR << "peptide stub atoms:\t" << pep_anchor_stub1 << "\t" << pep_anchor_stub2 << "\t" << pep_anchor_stub3 << "\n";
Size sd_denom( n_ref_poses );
Real max_std_devs( option[ pepspec::n_anchor_dock_std_devs ] );
// calc trans vector avg //
Vector jump_trans_vector_avg( 0 );
for ( Size i = 1; i <= n_ref_poses; ++i ) {
jump_trans_vector_avg += ( jump_trans_vector[i] / n_ref_poses );
}
// ...and std dev //
Real jump_trans_x_sd( 0 );
Real jump_trans_y_sd( 0 );
Real jump_trans_z_sd( 0 );
if ( option[ pepspec::prep_trans_std_dev ].user() ) {
jump_trans_x_sd = option[ pepspec::prep_trans_std_dev ];
jump_trans_y_sd = option[ pepspec::prep_trans_std_dev ];
jump_trans_z_sd = option[ pepspec::prep_trans_std_dev ];
} else {
for ( Size i = 1; i<= n_ref_poses; ++i ) {
jump_trans_x_sd += numeric::square( jump_trans_vector[i].x() - jump_trans_vector_avg.x() ) / ( sd_denom );
jump_trans_y_sd += numeric::square( jump_trans_vector[i].y() - jump_trans_vector_avg.y() ) / ( sd_denom );
jump_trans_z_sd += numeric::square( jump_trans_vector[i].z() - jump_trans_vector_avg.z() ) / ( sd_denom );
}
jump_trans_x_sd = max_std_devs * std::sqrt( jump_trans_x_sd );
jump_trans_y_sd = max_std_devs * std::sqrt( jump_trans_y_sd );
jump_trans_z_sd = max_std_devs * std::sqrt( jump_trans_z_sd );
}
Vector jump_trans_vector_sd( jump_trans_x_sd, jump_trans_y_sd, jump_trans_z_sd );
// unused ~Labonte
//Real jump_trans_magn_sd( std::sqrt( jump_trans_x_sd * jump_trans_x_sd + jump_trans_y_sd * jump_trans_y_sd + jump_trans_z_sd * jump_trans_z_sd ) );
if ( peptide_loop == 1 ) TR << "RB translation avg: x, y, z: " << jump_trans_vector_avg.x() << ", " << jump_trans_vector_avg.y() << ", " << jump_trans_vector_avg.z() << std::endl;
if ( peptide_loop == 1 ) TR << "Max RB translation deviation: x, y, z: " << jump_trans_x_sd << ", " << jump_trans_y_sd << ", " << jump_trans_z_sd << std::endl;
// calc orientation avgs //
jump_bond_angle = shift_angles( jump_bond_angle );
jump_tor1_angle = shift_angles( jump_tor1_angle );
jump_tor2_angle = shift_angles( jump_tor2_angle );
Real jump_bond_angle_avg( average( jump_bond_angle ) );
Real jump_tor1_angle_avg( average( jump_tor1_angle ) );
Real jump_tor2_angle_avg( average( jump_tor2_angle ) );
// ...and std devs //
Real jump_bond_angle_sd( 0 );
Real jump_tor1_angle_sd( 0 );
Real jump_tor2_angle_sd( 0 );
if ( option[ pepspec::prep_rot_std_dev ].user() ) {
jump_bond_angle_sd = radians( static_cast< Real >( option[ pepspec::prep_rot_std_dev ] ) );
jump_tor1_angle_sd = radians( static_cast< Real >( option[ pepspec::prep_rot_std_dev ] ) );
jump_tor2_angle_sd = radians( static_cast< Real >( option[ pepspec::prep_rot_std_dev ] ) );
} else {
for ( Size i = 1; i <= n_ref_poses; ++i ) {
jump_bond_angle_sd += numeric::square( jump_bond_angle[i] - jump_bond_angle_avg ) / ( sd_denom );
jump_tor1_angle_sd += numeric::square( jump_tor1_angle[i] - jump_tor1_angle_avg ) / ( sd_denom );
jump_tor2_angle_sd += numeric::square( jump_tor2_angle[i] - jump_tor2_angle_avg ) / ( sd_denom );
}
jump_bond_angle_sd = max_std_devs * std::sqrt( jump_bond_angle_sd );
jump_tor1_angle_sd = max_std_devs * std::sqrt( jump_tor1_angle_sd );
jump_tor2_angle_sd = max_std_devs * std::sqrt( jump_tor2_angle_sd );
}
if ( peptide_loop == 1 ) TR << "RB rotation avg: jump_bond_angle, jump_tor1, jump_tor2: " << degrees(jump_bond_angle_avg) << ", " << degrees(jump_tor1_angle_avg) << ", " << degrees(jump_tor2_angle_avg) << std::endl;
if ( peptide_loop == 1 ) TR << "Max RB rotation deviation: jump_bond_angle, jump_tor1, jump_tor2: " << degrees(jump_bond_angle_sd) << ", " << degrees(jump_tor1_angle_sd) << ", " << degrees(jump_tor2_angle_sd) << std::endl;
////////////////////////////////////////////////////////////////////
pose = start_pose;
pose.fold_tree( f_jump );
//set orientation to avg+-SD
{
Residue rsd1( pose.residue( prot_anchor ) );
Residue rsd2( pose.residue( pep_anchor ) );
StubID upstubid( AtomID( rsd1.atom_index( prot_anchor_stub1 ), prot_anchor ) ,
AtomID( rsd1.atom_index( prot_anchor_stub2 ), prot_anchor ) ,
AtomID( rsd1.atom_index( prot_anchor_stub3 ), prot_anchor ) ) ;
StubID downstubid( AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub3 ), pep_anchor ) ) ;
Real jump_trans_x_div( jump_trans_vector_avg.x() + ( 2 * numeric::random::rg().uniform() - 1 ) * jump_trans_x_sd );
Real jump_trans_y_div( jump_trans_vector_avg.y() + ( 2 * numeric::random::rg().uniform() - 1 ) * jump_trans_y_sd );
Real jump_trans_z_div( jump_trans_vector_avg.z() + ( 2 * numeric::random::rg().uniform() - 1 ) * jump_trans_z_sd );
Real jump_bond_angle_div( jump_bond_angle_avg + ( 2 * numeric::random::rg().uniform() - 1 ) * jump_bond_angle_sd );
Real jump_tor1_angle_div( jump_tor1_angle_avg + ( 2 * numeric::random::rg().uniform() - 1 ) * jump_tor1_angle_sd );
Real jump_tor2_angle_div( jump_tor2_angle_avg + ( 2 * numeric::random::rg().uniform() - 1 ) * jump_tor2_angle_sd );
Vector jump_trans_vector_div( jump_trans_x_div, jump_trans_y_div, jump_trans_z_div );
RT rt( jump_rot_matrix[1], jump_trans_vector_div );
pose.conformation().set_stub_transform( upstubid, downstubid, rt );
pose.fold_tree( f_orient );
pose.conformation().set_bond_angle( AtomID( rsd1.atom_index(prot_anchor_stub2), prot_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) ,
jump_bond_angle_div );
pose.conformation().set_torsion_angle( AtomID( rsd1.atom_index(prot_anchor_stub2), prot_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub3 ), pep_anchor ),
jump_tor1_angle_div );
pose.conformation().set_torsion_angle( AtomID( rsd1.atom_index(prot_anchor_stub1), prot_anchor ) ,
AtomID( rsd1.atom_index(prot_anchor_stub2), prot_anchor ),
AtomID( rsd2.atom_index( pep_anchor_stub1 ), pep_anchor ) ,
AtomID( rsd2.atom_index( pep_anchor_stub2 ), pep_anchor ) ,
jump_tor2_angle_div );
pose.fold_tree( f_jump );
}
/////////////////////////////////////////////////////////
Size ref_index( static_cast< int >( numeric::random::rg().uniform() * n_ref_poses + 1 ) );
if ( option[ pepspec::prep_use_ref_rotamers ] ) {
pose.replace_residue( pep_anchor, ref_poses[ ref_index ].residue( ref_pep_anchors[ ref_index ] ), true );
} else if ( option[ pepspec::homol_csts ].user() ) {
//set p0 homol_csts
scorefxn->set_weight( coordinate_constraint, 0.1 );
Vector p0_vect( pep_cst_ca_vects[ -1 * ref_pep_pos_min + 1 ] );
pep_coord_cst p0_cst;
p0_cst.atom_name = "CA";
p0_cst.pep_pos = 0;
p0_cst.x = p0_vect.x();
p0_cst.y = p0_vect.y();
p0_cst.z = p0_vect.z();
p0_cst.x0 = 0;
p0_cst.sd = 1.0;
p0_cst.tol = pep_cst_ca_tols[ -1 * ref_pep_pos_min + 1 ];
set_pep_cst( pose, pep_anchor, p0_cst );
}
vector1< bool > ignore_clash( pose.size(), false );
TR << "Ignoring clash residues:\t";
for ( Size i = 1; i <= pose.size() - 1; ++i ) {
vector1< bool > this_clash( pose.size(), false );
this_clash[ i ] = true;
if ( has_clash( pose, this_clash, scorefxn, option[ pepspec::clash_cutoff ], false ) ) {
TR << string_of( i ) + ", ";
ignore_clash[ i ] = true;
}
}
TR << "\n";
//Real Docking!!
//std::cout << "XUXA: ENTRA O NO ENTRA EN EL REAL DOCKING??" << pose << std::endl;
MonteCarloOP mc_dock2( new MonteCarlo( pose, *scorefxn, 0.8 ) );
pose.update_residue_neighbors();
Pose restart_pose( pose );
for ( Size i_dock = 1; i_dock <= Size(option[ pepspec::n_dock_loop]); ++i_dock ) {
pose = restart_pose;
( *scorefxn )( pose );
MonteCarloOP mc_dock( new MonteCarlo( pose, *scorefxn, 0.8 ) );
vector1< bool > check_clash( pose.size(), false );
check_clash[ pep_anchor ] = true;
rigid::RigidBodyPerturbNoCenterMoverOP rb_mover( new rigid::RigidBodyPerturbNoCenterMover( pep_jump, 2.5, 0.25 ) );
rb_mover->apply( pose );
mc_dock->boltzmann( pose );
//get seqpos nbrs from energy map and rottrials
vector1< bool > is_pep_nbr( pose.size(), false );
EnergyGraph const & energy_graph( pose.energies().energy_graph() );
for ( utility::graph::Graph::EdgeListConstIter
ir = energy_graph.get_node( pep_anchor )->const_edge_list_begin(),
ire = energy_graph.get_node( pep_anchor )->const_edge_list_end();
ir != ire; ++ir ) {
Size this_nbr( (*ir)->get_other_ind( pep_anchor ) );
is_pep_nbr[ this_nbr ] = true;
check_clash[ this_nbr ] = ( true && !ignore_clash[ this_nbr ] );
}
{
kinematics::MoveMapOP mm_min( new kinematics::MoveMap );
//mm_min->set_jump( pep_jump, true );
mm_min->set_chi( pep_anchor );
mm_min->set_chi( is_pep_nbr );
protocols::simple_moves::MinMoverOP min_mover( new protocols::simple_moves::MinMover( mm_min, scorefxn, "lbfgs_armijo_nonmonotone", 0.001, true ) );
min_mover->apply( pose );
}
mc_dock->boltzmann( pose );
( *soft_scorefxn )( pose );
pack::task::PackerTaskOP task( pack::task::TaskFactory::create_packer_task( pose ));
task->initialize_from_command_line().or_include_current( true );
for ( Size i=1; i<= pose.size(); ++i ) {
if ( !option[ pepspec::anchor_type ].user() && i == pep_anchor ) continue;
else if ( i == pep_anchor && option[ pepspec::prep_use_ref_rotamers ] ) task->nonconst_residue_task( i ).prevent_repacking();
else if ( i == pep_anchor || is_pep_nbr[ i ] ) task->nonconst_residue_task( i ).restrict_to_repacking();
else task->nonconst_residue_task( i ).prevent_repacking();
}
protocols::simple_moves::PackRotamersMoverOP packer( new protocols::simple_moves::PackRotamersMover( soft_scorefxn, task, 1 ) );
packer->apply( pose );
( *scorefxn )( pose );
{
kinematics::MoveMapOP mm_min( new kinematics::MoveMap );
//mm_min->set_jump( pep_jump, true );
mm_min->set_chi( pep_anchor );
mm_min->set_chi( is_pep_nbr );
protocols::simple_moves::MinMoverOP min_mover( new protocols::simple_moves::MinMover( mm_min, scorefxn, "lbfgs_armijo_nonmonotone", 0.001, true ) );
min_mover->apply( pose );
}
mc_dock->boltzmann( pose );
mc_dock->recover_low( pose );
mc_dock2->boltzmann( pose );
}
mc_dock2->recover_low( pose );
vector1< bool > check_clash( pose.size(), false );
EnergyGraph const & energy_graph( pose.energies().energy_graph() );
for ( utility::graph::Graph::EdgeListConstIter
ir = energy_graph.get_node( pep_anchor )->const_edge_list_begin(),
ire = energy_graph.get_node( pep_anchor )->const_edge_list_end();
ir != ire; ++ir ) {
Size this_nbr( (*ir)->get_other_ind( pep_anchor ) );
check_clash[ this_nbr ] = ( true && !ignore_clash[ this_nbr ] );
}
check_clash[ pep_anchor ] = true;
if ( has_clash( pose, check_clash, scorefxn, option[ pepspec::clash_cutoff ], true ) ) {
//dump_pdb( pose, "clash." + string_of( peptide_loop ) + ".pdb" );
TR << "Failed to resolve clash in iter " + string_of( peptide_loop ) + "\n";
if ( peptide_loop > 0 ) --peptide_loop;
continue;
}
std::string pdb_name ( option[ out::file::o ] );
if ( option[pepspec::n_peptides ] > 1 ) pdb_name += "_" + string_of( peptide_loop );
pdb_name += ".pdb";
( *scorefxn )( pose );
out_file << pdb_name + "\t";
out_file << pose.energies().total_energies().weighted_string_of( scorefxn->weights() );
Real total_score( pose.energies().total_energies().dot( scorefxn->weights() ) );
out_file << " total_score: " << total_score << "\t";
Real total_prot_score( total_score - prot_score );
out_file << " total-prot_score: " << total_prot_score << "\t";
if ( option[ pepspec::rmsd_analysis ] ) out_file << pep_rmsd_analysis( pose, prot_begin, prot_end, pep_anchor, pep_anchor, pep_anchor );
out_file << std::endl;
////////////////////////////////////////////////////////
Size n_append( option[ pepspec::n_append ] );
Size n_prepend( option[ pepspec::n_prepend ] );
ResidueOP ala( ResidueFactory::create_residue( rsd_set.name_map( "ALA" ) ) );
Size pep_begin( pep_anchor );
Size pep_end( pep_anchor );
for ( Size i = 1; i <= n_append; ++i ) {
pose.conformation().safely_append_polymer_residue_after_seqpos( *ala, pep_end, true );
++pep_end;
}
for ( Size i = 1; i <= n_prepend; ++i ) {
pose.conformation().safely_prepend_polymer_residue_before_seqpos( *ala, pep_begin, true );
++pep_anchor;
++pep_end;
}
for ( Size i_omega = pep_begin; i_omega <= pep_end - 1; ++i_omega ) {
pose.set_omega( i_omega, 180.0 );
}
if ( option[ pepspec::use_input_bb ] ) {
vector1< Size > ref_indices;
for ( Size ii = 1; ii <= n_ref_poses; ++ii ) ref_indices.push_back( ii );
//from -n to +m
int begin( pep_begin - pep_anchor );
int end( pep_end - pep_anchor );
numeric::random::random_permutation( ref_indices, numeric::random::rg() ); //shuffle ref poses
for ( Size i_ref = 1; i_ref <= n_ref_poses; ++i_ref ) {
ref_index = ref_indices[ i_ref ];
Pose ref_pose( ref_poses[ ref_index ] );
Size ref_pep_anchor( ref_pep_anchors[ ref_index ] );
Size ref_pep_begin( ref_pose.conformation().chain_begin( ref_pose.chain( ref_pep_anchor ) ) );
Size ref_pep_end( ref_pose.conformation().chain_end( ref_pose.chain( ref_pep_anchor ) ) );
int ref_begin = static_cast< int >( ref_pep_begin ) - static_cast< int >( ref_pep_anchor );
int ref_end = static_cast< int >( ref_pep_end ) - static_cast< int >( ref_pep_anchor );
//goto next if ref does not overlap
if ( begin < ref_begin || end > ref_end ) {
if ( i_ref == n_ref_poses ) utility_exit_with_message( "N append/prepend > all ref poses!\n" );
continue;
} else {
for ( int ii = begin; ii <= end; ++ii ) {
//or use first avail then goto next res
if ( ii > begin ) pose.set_phi( pep_anchor + ii, ref_pose.phi( ref_pep_anchor + ii ) );
pose.set_psi( pep_anchor + ii, ref_pose.psi( ref_pep_anchor + ii ) );
if ( ii < end ) {
pose.set_omega( pep_anchor + ii, ref_pose.omega( ref_pep_anchor + ii ) );
}
}
break;
}
}
}
dump_pdb( pose, pdb_name );
pdb_out_list_file << pdb_name << std::endl;
/*
Real cst_distance_n( pose.residue( prot_anchor ).xyz("CA").distance( pose.residue( new_pep_anchor ).xyz("N") ) );
Real cst_distance_ca( pose.residue( prot_anchor ).xyz("CA").distance( pose.residue( new_pep_anchor ).xyz("CA") ) );
Real cst_distance_c( pose.residue( prot_anchor ).xyz("CA").distance( pose.residue( new_pep_anchor ).xyz("C") ) );
std::string cst_file_name_str( option[ out::file::o ]+"_"+string_of(peptide_loop)+".cst" );
char const *cst_file_name = cst_file_name_str.c_str();
std::fstream cst_file( cst_file_name, std::ios::out );
cst_file << "[ atompairs ]\n";
cst_file << "CA\t" + string_of( prot_anchor ) + "\tN\t" + string_of( new_pep_anchor ) + "\tHARMONIC\t" + string_of( cst_distance_n ) + "\t0.1\n";
cst_file << "CA\t" + string_of( prot_anchor ) + "\tCA\t" + string_of( new_pep_anchor ) + "\tHARMONIC\t" + string_of( cst_distance_ca ) + "\t0.1\n";
cst_file << "CA\t" + string_of( prot_anchor ) + "\tC\t" + string_of( new_pep_anchor ) + "\tHARMONIC\t" + string_of( cst_distance_c ) + "\t0.1\n";
cst_list_file << cst_file_name_str << std::endl;
*/
}
}
int main( int argc, char * argv [] )
{
try {
using namespace basic::options;
using namespace basic::options::OptionKeys;
devel::init(argc, argv);
run_pep_prep();
TR.flush();
} catch ( utility::excn::EXCN_Base const & e ) {
std::cout << "caught exception " << e.msg() << std::endl;
return -1;
}
}
| [
"mjggodoy@gmail.com"
] | mjggodoy@gmail.com |
d4806c552762d7a5a0b092de8e33a4c288e3e768 | 453a249c45367fab253f497a4f543622648b037b | /gparser-parrellell/DepReader.h | 96875efe50914fd4cdff96b94cc8787fc969e17e | [] | no_license | zuiwufenghua/meishan-code | 8ddc7a07b59f75b39d85e70c91e3778b7dcedf1e | 976c7c600dd1b8237d556058d92ff232692f0522 | refs/heads/master | 2021-01-16T23:48:28.848548 | 2014-11-13T11:10:41 | 2014-11-13T11:10:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,443 | h | #ifndef _DEP_READER_
#define _DEP_READER_
#pragma once
#include <fstream>
#include <iostream>
using namespace std;
#include "DepInstance.h"
class DepReader
{
public:
DepReader();
virtual ~DepReader();
int startReading(const char *filename) {
if (m_inf.is_open()) {
/* cout << endl;
cout << ( m_inf.rdstate( ) & ios::badbit ) << endl;
cout << ( m_inf.rdstate( ) & ios::failbit ) << endl;
cout << ( m_inf.rdstate( ) & ios::eofbit ) << endl;
cout << m_inf.good() << endl;
cout << m_inf.bad() << endl;
cout << m_inf.fail() << endl;
cout << m_inf.eof() << endl;
cout << endl;
*/ m_inf.close();
m_inf.clear();
}
m_inf.open(filename);
/* cout << endl;
cout << ( m_inf.rdstate( ) & ios::badbit ) << endl;
cout << ( m_inf.rdstate( ) & ios::failbit ) << endl;
cout << ( m_inf.rdstate( ) & ios::eofbit ) << endl;
cout << m_inf.good() << endl;
cout << m_inf.bad() << endl;
cout << m_inf.fail() << endl;
cout << m_inf.eof() << endl;
cout << endl;
*/ if (!m_inf.is_open()) {
cout << "DepReader::startReading() open file err: " << filename << endl;
return -1;
}
// m_inf.seekg(0, ios_base::beg);
return 0;
}
void finishReading() {
if (m_inf.is_open()) {
m_inf.close();
m_inf.clear();
}
}
string normalize(const string &str);
virtual DepInstance *getNext() = 0;
protected:
ifstream m_inf;
// bool m_isLabeled;
int m_numInstance;
DepInstance m_instance;
};
#endif
| [
"mason.zms@gmail.com"
] | mason.zms@gmail.com |
41438f8aed6045cc8bf1bea30da5a189566b2c46 | 2c35da61dc41f8ff2c1588a2e66b61ca90cd1f3a | /dependencies/emscripten/box2d-emscripten/Dynamics/Joints/b2PrismaticJoint.cpp | d03eb6dd6da587c03671aa84bb4cf1bdea0b22f7 | [] | no_license | vkaytsanov/AngryBirds | 5858b3dad02940f21dfa849153a134645ecc2191 | 2cc1a7494f1c2c337461df73c4f43c57bfa57770 | refs/heads/master | 2023-06-17T10:27:37.254180 | 2021-07-08T11:37:00 | 2021-07-08T11:37:00 | 364,853,524 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,109 | cpp | /*
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.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.
*/
#include <box2d-emscripten/Dynamics/Joints/b2PrismaticJoint.h>
#include <box2d-emscripten/Dynamics/b2Body.h>
#include <box2d-emscripten/Dynamics/b2TimeStep.h>
// Linear constraint (point-to-line)
// d = p2 - p1 = x2 + r2 - x1 - r1
// C = dot(perp, d)
// Cdot = dot(d, cross(w1, perp)) + dot(perp, v2 + cross(w2, r2) - v1 - cross(w1, r1))
// = -dot(perp, v1) - dot(cross(d + r1, perp), w1) + dot(perp, v2) + dot(cross(r2, perp), v2)
// J = [-perp, -cross(d + r1, perp), perp, cross(r2,perp)]
//
// Angular constraint
// C = a2 - a1 + a_initial
// Cdot = w2 - w1
// J = [0 0 -1 0 0 1]
//
// K = J * invM * JT
//
// J = [-a -s1 a s2]
// [0 -1 0 1]
// a = perp
// s1 = cross(d + r1, a) = cross(p2 - x1, a)
// s2 = cross(r2, a) = cross(p2 - x2, a)
// Motor/Limit linear constraint
// C = dot(ax1, d)
// Cdot = = -dot(ax1, v1) - dot(cross(d + r1, ax1), w1) + dot(ax1, v2) + dot(cross(r2, ax1), v2)
// J = [-ax1 -cross(d+r1,ax1) ax1 cross(r2,ax1)]
// Block Solver
// We develop a block solver that includes the joint limit. This makes the limit stiff (inelastic) even
// when the mass has poor distribution (leading to large torques about the joint anchor points).
//
// The Jacobian has 3 rows:
// J = [-uT -s1 uT s2] // linear
// [0 -1 0 1] // angular
// [-vT -a1 vT a2] // limit
//
// u = perp
// v = axis
// s1 = cross(d + r1, u), s2 = cross(r2, u)
// a1 = cross(d + r1, v), a2 = cross(r2, v)
// M * (v2 - v1) = JT * df
// J * v2 = bias
//
// v2 = v1 + invM * JT * df
// J * (v1 + invM * JT * df) = bias
// K * df = bias - J * v1 = -Cdot
// K = J * invM * JT
// Cdot = J * v1 - bias
//
// Now solve for f2.
// df = f2 - f1
// K * (f2 - f1) = -Cdot
// f2 = invK * (-Cdot) + f1
//
// Clamp accumulated limit impulse.
// lower: f2(3) = max(f2(3), 0)
// upper: f2(3) = min(f2(3), 0)
//
// Solve for correct f2(1:2)
// K(1:2, 1:2) * f2(1:2) = -Cdot(1:2) - K(1:2,3) * f2(3) + K(1:2,1:3) * f1
// = -Cdot(1:2) - K(1:2,3) * f2(3) + K(1:2,1:2) * f1(1:2) + K(1:2,3) * f1(3)
// K(1:2, 1:2) * f2(1:2) = -Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3)) + K(1:2,1:2) * f1(1:2)
// f2(1:2) = invK(1:2,1:2) * (-Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3))) + f1(1:2)
//
// Now compute impulse to be applied:
// df = f2 - f1
void b2PrismaticJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor, const b2Vec2& axis)
{
bodyA = bA;
bodyB = bB;
localAnchorA = bodyA->GetLocalPoint(anchor);
localAnchorB = bodyB->GetLocalPoint(anchor);
localAxisA = bodyA->GetLocalVector(axis);
referenceAngle = bodyB->GetAngle() - bodyA->GetAngle();
}
b2PrismaticJoint::b2PrismaticJoint(const b2PrismaticJointDef* def)
: b2Joint(def)
{
m_localAnchorA = def->localAnchorA;
m_localAnchorB = def->localAnchorB;
m_localXAxisA = def->localAxisA;
m_localXAxisA.Normalize();
m_localYAxisA = b2Cross(1.0f, m_localXAxisA);
m_referenceAngle = def->referenceAngle;
m_impulse.SetZero();
m_motorMass = 0.0;
m_motorImpulse = 0.0f;
m_lowerTranslation = def->lowerTranslation;
m_upperTranslation = def->upperTranslation;
m_maxMotorForce = def->maxMotorForce;
m_motorSpeed = def->motorSpeed;
m_enableLimit = def->enableLimit;
m_enableMotor = def->enableMotor;
m_limitState = e_inactiveLimit;
m_axis.SetZero();
m_perp.SetZero();
}
void b2PrismaticJoint::InitVelocityConstraints(const b2SolverData& data)
{
m_indexA = m_bodyA->m_islandIndex;
m_indexB = m_bodyB->m_islandIndex;
m_localCenterA = m_bodyA->m_sweep.localCenter;
m_localCenterB = m_bodyB->m_sweep.localCenter;
m_invMassA = m_bodyA->m_invMass;
m_invMassB = m_bodyB->m_invMass;
m_invIA = m_bodyA->m_invI;
m_invIB = m_bodyB->m_invI;
b2Vec2 cA = data.positions[m_indexA].c;
float32 aA = data.positions[m_indexA].a;
b2Vec2 vA = data.velocities[m_indexA].v;
float32 wA = data.velocities[m_indexA].w;
b2Vec2 cB = data.positions[m_indexB].c;
float32 aB = data.positions[m_indexB].a;
b2Vec2 vB = data.velocities[m_indexB].v;
float32 wB = data.velocities[m_indexB].w;
b2Rot qA(aA), qB(aB);
// Compute the effective masses.
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
b2Vec2 d = (cB - cA) + rB - rA;
float32 mA = m_invMassA, mB = m_invMassB;
float32 iA = m_invIA, iB = m_invIB;
// Compute motor Jacobian and effective mass.
{
m_axis = b2Mul(qA, m_localXAxisA);
m_a1 = b2Cross(d + rA, m_axis);
m_a2 = b2Cross(rB, m_axis);
m_motorMass = mA + mB + iA * m_a1 * m_a1 + iB * m_a2 * m_a2;
if (m_motorMass > 0.0f)
{
m_motorMass = 1.0f / m_motorMass;
}
}
// Prismatic constraint.
{
m_perp = b2Mul(qA, m_localYAxisA);
m_s1 = b2Cross(d + rA, m_perp);
m_s2 = b2Cross(rB, m_perp);
float32 k11 = mA + mB + iA * m_s1 * m_s1 + iB * m_s2 * m_s2;
float32 k12 = iA * m_s1 + iB * m_s2;
float32 k13 = iA * m_s1 * m_a1 + iB * m_s2 * m_a2;
float32 k22 = iA + iB;
if (k22 == 0.0f)
{
// For bodies with fixed rotation.
k22 = 1.0f;
}
float32 k23 = iA * m_a1 + iB * m_a2;
float32 k33 = mA + mB + iA * m_a1 * m_a1 + iB * m_a2 * m_a2;
m_K.ex.Set(k11, k12, k13);
m_K.ey.Set(k12, k22, k23);
m_K.ez.Set(k13, k23, k33);
}
// Compute motor and limit terms.
if (m_enableLimit)
{
float32 jointTranslation = b2Dot(m_axis, d);
if (b2Abs(m_upperTranslation - m_lowerTranslation) < 2.0f * b2_linearSlop)
{
m_limitState = e_equalLimits;
}
else if (jointTranslation <= m_lowerTranslation)
{
if (m_limitState != e_atLowerLimit)
{
m_limitState = e_atLowerLimit;
m_impulse.z = 0.0f;
}
}
else if (jointTranslation >= m_upperTranslation)
{
if (m_limitState != e_atUpperLimit)
{
m_limitState = e_atUpperLimit;
m_impulse.z = 0.0f;
}
}
else
{
m_limitState = e_inactiveLimit;
m_impulse.z = 0.0f;
}
}
else
{
m_limitState = e_inactiveLimit;
m_impulse.z = 0.0f;
}
if (m_enableMotor == false)
{
m_motorImpulse = 0.0f;
}
if (data.step.warmStarting)
{
// Account for variable time step.
m_impulse *= data.step.dtRatio;
m_motorImpulse *= data.step.dtRatio;
b2Vec2 P = m_impulse.x * m_perp + (m_motorImpulse + m_impulse.z) * m_axis;
float32 LA = m_impulse.x * m_s1 + m_impulse.y + (m_motorImpulse + m_impulse.z) * m_a1;
float32 LB = m_impulse.x * m_s2 + m_impulse.y + (m_motorImpulse + m_impulse.z) * m_a2;
vA -= mA * P;
wA -= iA * LA;
vB += mB * P;
wB += iB * LB;
}
else
{
m_impulse.SetZero();
m_motorImpulse = 0.0f;
}
data.velocities[m_indexA].v = vA;
data.velocities[m_indexA].w = wA;
data.velocities[m_indexB].v = vB;
data.velocities[m_indexB].w = wB;
}
void b2PrismaticJoint::SolveVelocityConstraints(const b2SolverData& data)
{
b2Vec2 vA = data.velocities[m_indexA].v;
float32 wA = data.velocities[m_indexA].w;
b2Vec2 vB = data.velocities[m_indexB].v;
float32 wB = data.velocities[m_indexB].w;
float32 mA = m_invMassA, mB = m_invMassB;
float32 iA = m_invIA, iB = m_invIB;
// Solve linear motor constraint.
if (m_enableMotor && m_limitState != e_equalLimits)
{
float32 Cdot = b2Dot(m_axis, vB - vA) + m_a2 * wB - m_a1 * wA;
float32 impulse = m_motorMass * (m_motorSpeed - Cdot);
float32 oldImpulse = m_motorImpulse;
float32 maxImpulse = data.step.dt * m_maxMotorForce;
m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
impulse = m_motorImpulse - oldImpulse;
b2Vec2 P = impulse * m_axis;
float32 LA = impulse * m_a1;
float32 LB = impulse * m_a2;
vA -= mA * P;
wA -= iA * LA;
vB += mB * P;
wB += iB * LB;
}
b2Vec2 Cdot1;
Cdot1.x = b2Dot(m_perp, vB - vA) + m_s2 * wB - m_s1 * wA;
Cdot1.y = wB - wA;
if (m_enableLimit && m_limitState != e_inactiveLimit)
{
// Solve prismatic and limit constraint in block form.
float32 Cdot2;
Cdot2 = b2Dot(m_axis, vB - vA) + m_a2 * wB - m_a1 * wA;
b2Vec3 Cdot(Cdot1.x, Cdot1.y, Cdot2);
b2Vec3 f1 = m_impulse;
b2Vec3 df = m_K.Solve33(-Cdot);
m_impulse += df;
if (m_limitState == e_atLowerLimit)
{
m_impulse.z = b2Max(m_impulse.z, 0.0f);
}
else if (m_limitState == e_atUpperLimit)
{
m_impulse.z = b2Min(m_impulse.z, 0.0f);
}
// f2(1:2) = invK(1:2,1:2) * (-Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3))) + f1(1:2)
b2Vec2 b = -Cdot1 - (m_impulse.z - f1.z) * b2Vec2(m_K.ez.x, m_K.ez.y);
b2Vec2 f2r = m_K.Solve22(b) + b2Vec2(f1.x, f1.y);
m_impulse.x = f2r.x;
m_impulse.y = f2r.y;
df = m_impulse - f1;
b2Vec2 P = df.x * m_perp + df.z * m_axis;
float32 LA = df.x * m_s1 + df.y + df.z * m_a1;
float32 LB = df.x * m_s2 + df.y + df.z * m_a2;
vA -= mA * P;
wA -= iA * LA;
vB += mB * P;
wB += iB * LB;
}
else
{
// Limit is inactive, just solve the prismatic constraint in block form.
b2Vec2 df = m_K.Solve22(-Cdot1);
m_impulse.x += df.x;
m_impulse.y += df.y;
b2Vec2 P = df.x * m_perp;
float32 LA = df.x * m_s1 + df.y;
float32 LB = df.x * m_s2 + df.y;
vA -= mA * P;
wA -= iA * LA;
vB += mB * P;
wB += iB * LB;
b2Vec2 Cdot10 = Cdot1;
Cdot1.x = b2Dot(m_perp, vB - vA) + m_s2 * wB - m_s1 * wA;
Cdot1.y = wB - wA;
if (b2Abs(Cdot1.x) > 0.01f || b2Abs(Cdot1.y) > 0.01f)
{
b2Vec2 test = b2Mul22(m_K, df);
Cdot1.x += 0.0f;
}
}
data.velocities[m_indexA].v = vA;
data.velocities[m_indexA].w = wA;
data.velocities[m_indexB].v = vB;
data.velocities[m_indexB].w = wB;
}
bool b2PrismaticJoint::SolvePositionConstraints(const b2SolverData& data)
{
b2Vec2 cA = data.positions[m_indexA].c;
float32 aA = data.positions[m_indexA].a;
b2Vec2 cB = data.positions[m_indexB].c;
float32 aB = data.positions[m_indexB].a;
b2Rot qA(aA), qB(aB);
float32 mA = m_invMassA, mB = m_invMassB;
float32 iA = m_invIA, iB = m_invIB;
// Compute fresh Jacobians
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
b2Vec2 d = cB + rB - cA - rA;
b2Vec2 axis = b2Mul(qA, m_localXAxisA);
float32 a1 = b2Cross(d + rA, axis);
float32 a2 = b2Cross(rB, axis);
b2Vec2 perp = b2Mul(qA, m_localYAxisA);
float32 s1 = b2Cross(d + rA, perp);
float32 s2 = b2Cross(rB, perp);
b2Vec3 impulse;
b2Vec2 C1;
C1.x = b2Dot(perp, d);
C1.y = aB - aA - m_referenceAngle;
float32 linearError = b2Abs(C1.x);
float32 angularError = b2Abs(C1.y);
bool active = false;
float32 C2 = 0.0f;
if (m_enableLimit)
{
float32 translation = b2Dot(axis, d);
if (b2Abs(m_upperTranslation - m_lowerTranslation) < 2.0f * b2_linearSlop)
{
// Prevent large angular corrections
C2 = b2Clamp(translation, -b2_maxLinearCorrection, b2_maxLinearCorrection);
linearError = b2Max(linearError, b2Abs(translation));
active = true;
}
else if (translation <= m_lowerTranslation)
{
// Prevent large linear corrections and allow some slop.
C2 = b2Clamp(translation - m_lowerTranslation + b2_linearSlop, -b2_maxLinearCorrection, 0.0f);
linearError = b2Max(linearError, m_lowerTranslation - translation);
active = true;
}
else if (translation >= m_upperTranslation)
{
// Prevent large linear corrections and allow some slop.
C2 = b2Clamp(translation - m_upperTranslation - b2_linearSlop, 0.0f, b2_maxLinearCorrection);
linearError = b2Max(linearError, translation - m_upperTranslation);
active = true;
}
}
if (active)
{
float32 k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2;
float32 k12 = iA * s1 + iB * s2;
float32 k13 = iA * s1 * a1 + iB * s2 * a2;
float32 k22 = iA + iB;
if (k22 == 0.0f)
{
// For fixed rotation
k22 = 1.0f;
}
float32 k23 = iA * a1 + iB * a2;
float32 k33 = mA + mB + iA * a1 * a1 + iB * a2 * a2;
b2Mat33 K;
K.ex.Set(k11, k12, k13);
K.ey.Set(k12, k22, k23);
K.ez.Set(k13, k23, k33);
b2Vec3 C;
C.x = C1.x;
C.y = C1.y;
C.z = C2;
impulse = K.Solve33(-C);
}
else
{
float32 k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2;
float32 k12 = iA * s1 + iB * s2;
float32 k22 = iA + iB;
if (k22 == 0.0f)
{
k22 = 1.0f;
}
b2Mat22 K;
K.ex.Set(k11, k12);
K.ey.Set(k12, k22);
b2Vec2 impulse1 = K.Solve(-C1);
impulse.x = impulse1.x;
impulse.y = impulse1.y;
impulse.z = 0.0f;
}
b2Vec2 P = impulse.x * perp + impulse.z * axis;
float32 LA = impulse.x * s1 + impulse.y + impulse.z * a1;
float32 LB = impulse.x * s2 + impulse.y + impulse.z * a2;
cA -= mA * P;
aA -= iA * LA;
cB += mB * P;
aB += iB * LB;
data.positions[m_indexA].c = cA;
data.positions[m_indexA].a = aA;
data.positions[m_indexB].c = cB;
data.positions[m_indexB].a = aB;
return linearError <= b2_linearSlop && angularError <= b2_angularSlop;
}
b2Vec2 b2PrismaticJoint::GetAnchorA() const
{
return m_bodyA->GetWorldPoint(m_localAnchorA);
}
b2Vec2 b2PrismaticJoint::GetAnchorB() const
{
return m_bodyB->GetWorldPoint(m_localAnchorB);
}
b2Vec2 b2PrismaticJoint::GetReactionForce(float32 inv_dt) const
{
return inv_dt * (m_impulse.x * m_perp + (m_motorImpulse + m_impulse.z) * m_axis);
}
float32 b2PrismaticJoint::GetReactionTorque(float32 inv_dt) const
{
return inv_dt * m_impulse.y;
}
float32 b2PrismaticJoint::GetJointTranslation() const
{
b2Vec2 pA = m_bodyA->GetWorldPoint(m_localAnchorA);
b2Vec2 pB = m_bodyB->GetWorldPoint(m_localAnchorB);
b2Vec2 d = pB - pA;
b2Vec2 axis = m_bodyA->GetWorldVector(m_localXAxisA);
float32 translation = b2Dot(d, axis);
return translation;
}
float32 b2PrismaticJoint::GetJointSpeed() const
{
b2Body* bA = m_bodyA;
b2Body* bB = m_bodyB;
b2Vec2 rA = b2Mul(bA->m_xf.q, m_localAnchorA - bA->m_sweep.localCenter);
b2Vec2 rB = b2Mul(bB->m_xf.q, m_localAnchorB - bB->m_sweep.localCenter);
b2Vec2 p1 = bA->m_sweep.c + rA;
b2Vec2 p2 = bB->m_sweep.c + rB;
b2Vec2 d = p2 - p1;
b2Vec2 axis = b2Mul(bA->m_xf.q, m_localXAxisA);
b2Vec2 vA = bA->m_linearVelocity;
b2Vec2 vB = bB->m_linearVelocity;
float32 wA = bA->m_angularVelocity;
float32 wB = bB->m_angularVelocity;
float32 speed = b2Dot(d, b2Cross(wA, axis)) + b2Dot(axis, vB + b2Cross(wB, rB) - vA - b2Cross(wA, rA));
return speed;
}
bool b2PrismaticJoint::IsLimitEnabled() const
{
return m_enableLimit;
}
void b2PrismaticJoint::EnableLimit(bool flag)
{
if (flag != m_enableLimit)
{
m_bodyA->SetAwake(true);
m_bodyB->SetAwake(true);
m_enableLimit = flag;
m_impulse.z = 0.0f;
}
}
float32 b2PrismaticJoint::GetLowerLimit() const
{
return m_lowerTranslation;
}
float32 b2PrismaticJoint::GetUpperLimit() const
{
return m_upperTranslation;
}
void b2PrismaticJoint::SetLimits(float32 lower, float32 upper)
{
b2Assert(lower <= upper);
if (lower != m_lowerTranslation || upper != m_upperTranslation)
{
m_bodyA->SetAwake(true);
m_bodyB->SetAwake(true);
m_lowerTranslation = lower;
m_upperTranslation = upper;
m_impulse.z = 0.0f;
}
}
bool b2PrismaticJoint::IsMotorEnabled() const
{
return m_enableMotor;
}
void b2PrismaticJoint::EnableMotor(bool flag)
{
m_bodyA->SetAwake(true);
m_bodyB->SetAwake(true);
m_enableMotor = flag;
}
void b2PrismaticJoint::SetMotorSpeed(float32 speed)
{
m_bodyA->SetAwake(true);
m_bodyB->SetAwake(true);
m_motorSpeed = speed;
}
void b2PrismaticJoint::SetMaxMotorForce(float32 force)
{
m_bodyA->SetAwake(true);
m_bodyB->SetAwake(true);
m_maxMotorForce = force;
}
float32 b2PrismaticJoint::GetMotorForce(float32 inv_dt) const
{
return inv_dt * m_motorImpulse;
}
void b2PrismaticJoint::Dump()
{
int32 indexA = m_bodyA->m_islandIndex;
int32 indexB = m_bodyB->m_islandIndex;
b2Log(" b2PrismaticJointDef jd;\n");
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
b2Log(" jd.localAxisA.Set(%.15lef, %.15lef);\n", m_localXAxisA.x, m_localXAxisA.y);
b2Log(" jd.referenceAngle = %.15lef;\n", m_referenceAngle);
b2Log(" jd.enableLimit = bool(%d);\n", m_enableLimit);
b2Log(" jd.lowerTranslation = %.15lef;\n", m_lowerTranslation);
b2Log(" jd.upperTranslation = %.15lef;\n", m_upperTranslation);
b2Log(" jd.enableMotor = bool(%d);\n", m_enableMotor);
b2Log(" jd.motorSpeed = %.15lef;\n", m_motorSpeed);
b2Log(" jd.maxMotorForce = %.15lef;\n", m_maxMotorForce);
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
}
| [
"vkaytsanov@yahoo.com"
] | vkaytsanov@yahoo.com |
94ac107375e827c14643db2f1763f027b9b0d765 | 13d789d505fdb75b1dff45f0ea173ecc1d6ca440 | /examples/laplace_aztec/main.cpp | 756a1c9ca5fae15225f114812df0249904114e83 | [
"MIT"
] | permissive | bstaber/TrilinosUQComp | 209d39abe41aef14cfb0c2da039476f1a0815ba1 | 12ada5a678338a1da962113a4fad708f93b19e03 | refs/heads/master | 2022-03-30T10:33:09.066090 | 2020-01-10T15:48:01 | 2020-01-10T15:48:01 | 92,018,402 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,337 | cpp | #include "Epetra_ConfigDefs.h"
#ifdef HAVE_MPI
#include "mpi.h"
#include "Epetra_MpiComm.h"
#else
#include "Epetra_SerialComm.h"
#endif
#include "meshpp.hpp"
#include "laplacepp.hpp"
int main(int argc, char *argv[]){
#ifdef HAVE_MPI
MPI_Init(&argc, &argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
//Create a parameter list and two sublists "Mesh" and "Laplace".
Teuchos::ParameterList Laplace_parameters;
Teuchos::ParameterList & mesh_sublist = Laplace_parameters.sublist("Mesh");
Teuchos::ParameterList & aztec_sublist = Laplace_parameters.sublist("Aztec");
Teuchos::ParameterList & amesos_sublist = Laplace_parameters.sublist("Amesos");
unsigned int nb_phys_groups = 4;
mesh_sublist.set("mesh_file","test2.msh");
mesh_sublist.set("boundary_file","nodes_to_boundaries_less_bumpy.txt");
mesh_sublist.set("nb_phys_groups",nb_phys_groups);
aztec_sublist.set("solver", "cg");
aztec_sublist.set("precond", "jacobi");
//aztec_sublist.set("subdomain_solve", "ilut");
aztec_sublist.set("AZ_conv", "noscaled");
aztec_sublist.set("AZ_tol", 1e-6);
aztec_sublist.set("AZ_output", 0);
aztec_sublist.set("AZ_diagnostics", 0);
aztec_sublist.set("AZ_reorder", 1);
bool display = 1;
amesos_sublist.set("display",display);
amesos_sublist.set("solver_type","Mumps");
//$$ Laplace example
Teuchos::RCP<laplace> LaplaceO = Teuchos::rcp(new laplace(Comm,Laplace_parameters.sublist("Mesh")));
Epetra_FECrsMatrix matrix(Copy,*LaplaceO->FEGraph);
Epetra_Vector lhs(*LaplaceO->StandardMap);
Epetra_FEVector rhs(*LaplaceO->StandardMap);
//Problem number one with aztec
int bc_indx[2];
double bc_val[2];
bc_indx[0] = 0; bc_indx[1] = 1;
bc_val[0] = 0.0; bc_val[1] = 1.0;
LaplaceO->solve_aztec(Laplace_parameters.sublist("Aztec"), matrix, lhs, rhs, &bc_indx[0], &bc_val[0]);
LaplaceO->print_solution(lhs, "laplace_inner_to_outer_aztec.mtx");
//Problem number two with aztec
bc_indx[0] = 2; bc_indx[1] = 3;
LaplaceO->solve_aztec(Laplace_parameters.sublist("Aztec"), matrix, lhs, rhs, &bc_indx[0], &bc_val[0]);
LaplaceO->print_solution(lhs, "laplace_inlet_to_outlet_aztec.mtx");
//$$ End example
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return 0;
}
| [
"brian.staber@gmail.com"
] | brian.staber@gmail.com |
5939e1e1fa6155807353d259fecaeb2e2bf61371 | 9b74579b3feb6d67403464a2769ae1ce50a6c01b | /server/include/components/CollisionBox.hpp | 4f83eab702a5d0f727d51a69bfdc69ebdae934a3 | [] | no_license | Aelerinya/rtype | 551679c915cf770499d2f9cbf404cbfb34c223cc | 9db3902087f92458bd2433cd7f9a255b9813cece | refs/heads/main | 2023-07-20T15:31:49.105106 | 2020-11-28T11:20:28 | 2020-11-28T11:20:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 412 | hpp | #ifndef COLLISION_BOX_HPP
#define COLLISION_BOX_HPP
#include "GameObject.hpp"
#include <functional>
#include <optional>
#include <vector>
struct CollisionBox {
float width;
float height;
float offset_x = 0;
float offset_y = 0;
unsigned roughness = 1;
std::vector<GameObject> ignoreList = {};
std::optional<GameObject> collidingWith = {};
float colliderRoughness = 0;
};
#endif
| [
"alexis.crozet@epitech.eu"
] | alexis.crozet@epitech.eu |
c44f334e3338b533fb00531f204097974b10f9bb | 792890dbab2a8329c44c063af23377708438230a | /roamfree/ROAMfunctions/include/ROAMfunctions/ImagePlaneProjectionM.h | 17ad51e18f8a1595be46aeb69b5e3421725f6ae4 | [] | no_license | ffgamelife/ROAMFREE | dc5d84eba514dbf928819e209af8053fc21fd23b | 1d63b5e9e7dd63ee76165485b00c027f431987e3 | refs/heads/master | 2023-01-23T02:51:54.481566 | 2020-11-29T12:53:56 | 2020-11-29T12:53:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,574 | h | /*
Copyright (c) 2013-2016 Politecnico di Milano.
All rights reserved. This program and the accompanying materials
are made available under the terms of the GNU Lesser Public License v3
which accompanies this distribution, and is available at
https://www.gnu.org/licenses/lgpl.html
Contributors:
Davide A. Cucci (davide.cucci@epfl.ch)
*/
/*
* ImagePlaneProjectionM.h
*
* Created on: Oct 09, 2014
* Author: davide
*/
#ifndef IMAGEPLANEPROJECTION_H_
#define IMAGEPLANEPROJECTION_H_
#include <Eigen/Dense>
#include <iostream>
namespace ROAMfunctions {
class ImagePlaneProjectionM {
public:
static const bool _usedComponents[];
static const std::string _paramsNames[];
static const int _nParams = 4;
static const unsigned int _ORDER = 0;
static const unsigned int _ERROR_SIZE = 2;
static const unsigned int _NOISE_SIZE = 2;
static const unsigned int _MEASUREMENT_SIZE = 2;
const std::string* getParamsList() {
return _paramsNames;
}
const int getNParams() {
return _nParams;
}
bool predict(const Eigen::VectorXd &x, double **params,
const Eigen::VectorXd& z, double dt, Eigen::VectorXd &xhat) {
return false;
}
template<typename T>
bool error(const Eigen::VectorXd &x, double **params,
const Eigen::VectorXd& z, Eigen::MatrixBase<T> const &const_ret) {
Eigen::Map<Eigen::Vector3d> lw(params[0]);
Eigen::Map<Eigen::Vector3d> cm(params[1]);
Eigen::Map<Eigen::Vector3d> rd(params[2]);
Eigen::Map<Eigen::Vector2d> td(params[3]);
Eigen::MatrixBase<T> & err = const_cast<Eigen::MatrixBase<T>&>(const_ret);
const static int _OFF = -1;
# include "generated/ImagePlaneProjection_Err.cppready"
return false;
}
template<typename T>
bool errorJacobian(const Eigen::VectorXd &x, double **params,
const Eigen::VectorXd& z, int wrt,
Eigen::MatrixBase<T> const &const_ret) {
Eigen::Map<Eigen::Vector3d> lw(params[0]);
Eigen::Map<Eigen::Vector3d> cm(params[1]);
Eigen::Map<Eigen::Vector3d> rd(params[2]);
Eigen::Map<Eigen::Vector2d> td(params[3]);
Eigen::MatrixBase<T> & J = const_cast<Eigen::MatrixBase<T>&>(const_ret);
const static int _OFF = -1;
switch (wrt) {
case -2: // jacobian wrt to q
{
# include "generated/ImagePlaneProjection_JErrQ.cppready"
return true;
break;
}
case -1: // jacobian wrt pose
{
# include "generated/ImagePlaneProjection_JErrPose.cppready"
return true;
break;
}
case 0: // jacobian wrt to noises
{
// it is the identity matrix
// #include "generated/ImagePlaneProjection_JErrNoises.cppready"
return false;
break;
}
case 1: // jacobian wrt landmark
{
# include "generated/ImagePlaneProjection_JErrLw.cppready"
return true;
break;
}
case 2: // jacobian wrt camera matrix
{
# include "generated/ImagePlaneProjection_JErrCM.cppready"
return true;
break;
}
case 3: // jacobian wrt radial distortion
{
# include "generated/ImagePlaneProjection_JErrRD.cppready"
return true;
break;
}
case 4: // jacobian wrt tangential distortion
{
# include "generated/ImagePlaneProjection_JErrTD.cppready"
return true;
break;
}
}
assert(false);
return false;
}
};
} /* namespace ROAMfunctions */
#endif /* IMAGEPLANEPROJECTION_H_ */
| [
"davide.cucci@epfl.ch"
] | davide.cucci@epfl.ch |
427e9fb923e95618dc5e4c23672b052dd3b370a4 | ceda3349a29fa1a2aa067887d427db3d45c41d81 | /Classes/StatusLayer.h | 477e311bacbaf480473ccf8b9dd1b1e618813a06 | [] | no_license | poros666/cocos_2d_moba | 235c28e53b3b16acc0e35585437ed2019283fa46 | f19027b7d446fe7e63b5735a6804aa2f05d779de | refs/heads/master | 2020-05-26T06:20:11.965996 | 2019-06-16T15:11:26 | 2019-06-16T15:11:26 | 188,133,543 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 315 | h | #pragma once
#include "cocos2d.h"
#include "OneMapLayer.h"
#include "Hero.h"
class StatusLayer :public cocos2d::Layer
{
public:
static cocos2d::Layer* createLayer();
virtual bool init();
virtual void update(float dt);
void setHPprogress(int initHealthPointsLimit,int healthPoints);
CREATE_FUNC(StatusLayer);
}; | [
"1196128112@qq.com"
] | 1196128112@qq.com |
3c6e09cb03114fafdc2e087e710a4d78af11e84f | 005ccb2375b571381096f9bd85b4e5d3e231257d | /early_models/flapping_wing_ff_original/backGround/system/controlDict | 3405a417733ba76cf5f90327b090f1a2b239abf2 | [] | no_license | lhooz/flapping_model_openfoam | b2be4d7873bbe3686533bfbe07b5b2441053280d | 7561787ccfc51afe453e5df0d0f25e395703e7d3 | refs/heads/master | 2022-12-28T14:23:20.798833 | 2020-10-07T22:27:08 | 2020-10-07T22:27:08 | 274,503,779 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,773 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 7 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application pimpleFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 18;
deltaT 1e-4;
writeControl adjustableRunTime;
writeInterval 0.1;
purgeWrite 0;
writeFormat ascii;
writePrecision 10;
writeCompression off;
timeFormat general;
timePrecision 10;
runTimeModifiable true;
/*adjustTimeStep yes;
maxCo 1;
maxDeltaT 0.1;*/
// ************************************************************************* //
functions
{
///////////////////////////////////////////////////////////////////////////
forces_object
{
type forces;
libs ("libforces.so");
patches (wing);
writeControl writeTime;
//writeControl timeStep;
//writeInterval 1;
//// Name of fields
pName p;
UName U;
//// Density
rho rhoInf;
rhoInf 1;
//// Centre of rotation
CofR (0 0 0);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
forceCoeffs_object
{
// rhoInf - reference density
// CofR - Centre of rotation
// dragDir - Direction of drag coefficient
// liftDir - Direction of lift coefficient
// pitchAxis - Pitching moment axis
// magUinf - free stream velocity magnitude
// lRef - reference length
// Aref - reference area
type forceCoeffs;
libs ("libforces.so");
patches (wing);
writeControl writeTime;
//writeControl timeStep;
//writeInterval 1;
pName p;
Uname U;
rho rhoInf;
rhoInf 1;
//// Dump to file
log true;
CofR (0 0 0);
liftDir (0 1 0);
dragDir (0 0 1);
pitchAxis (1 0 0);
magUInf 22.915;
lRef 1.0; // reference lenght for moments!!!
Aref 3.73; // reference area
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
fieldAverage
{
type fieldAverage;
libs ("libfieldFunctionObjects.so");
enabled true;
writeControl writeTime;
//writeControl timeStep;
//writeInterval 100;
//cleanRestart true;
//timeStart 20;
//timeEnd 200;
fields
(
U
{
mean on;
prime2Mean on;
base time;
}
p
{
mean on;
prime2Mean on;
base time;
}
);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
minmaxdomain
{
type fieldMinMax;
//type banana;
libs ("libfieldFunctionObjects.so");
enabled true;
mode component;
writeControl writeTime;
//writeControl timeStep;
//writeInterval 1;
log true;
fields (p U);
}
///////////////////////////////////////////////////////////////////////////
};
| [
"hao.lee0019@gmail.com"
] | hao.lee0019@gmail.com | |
95939b215bc96f460b67a4b11fd46e870981fe56 | a946bd87890dc390fa732e4c82d3ec0c2e510b5d | /Source/NotCatan/DiceRoll.cpp | 9a696a01908ccdc0b0741bf8624735625cbb0766 | [] | no_license | Rizler/not-catan | d05ae2acee8c5ad74d6a1af02529ed8a3204331e | 38933dcd5ef46a8085db84f90091722b9c668845 | refs/heads/master | 2022-06-05T21:45:20.575119 | 2022-04-30T11:28:37 | 2022-04-30T11:28:37 | 116,809,273 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 171 | cpp | #include "DiceRoll.h"
FDiceRoll::FDiceRoll()
{
roll();
}
void FDiceRoll::roll()
{
die1 = FMath::RandRange(1, 6);
die2 = FMath::RandRange(1, 6);
sum = die1 + die2;
}
| [
"niry33@gmail.com"
] | niry33@gmail.com |
3bc6069927ac8ee72c917db44396acc280366982 | b4a537160bc8aee055534280b8564992d05d4245 | /15000/15727.cpp | 96bcad896bff3d9b545dc681f591de3f66240ce4 | [] | no_license | kadragon/acmicpc | c90d8658969d9bcbecd7ac45a188ac1ad4ad1dd3 | b76bb7b545256631212ea0a2010d2c485dbd3e40 | refs/heads/master | 2021-07-13T01:45:03.963267 | 2021-04-18T07:33:08 | 2021-04-18T07:33:08 | 244,813,052 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 241 | cpp | //
// Created by kangdonguk on 2020/06/21.
//
// https://www.acmicpc.net/problem/15727
// 조별과제를 하려는데 조장이 사라졌다
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
printf("%d", (n + 4) / 5);
} | [
"kangdongouk@gmail.com"
] | kangdongouk@gmail.com |
db0159ed91ff2b076af21b30ae17b9ce076ae19e | 3f3095dbf94522e37fe897381d9c76ceb67c8e4f | /Current/BP_TikiTorch.hpp | a156e45663659e60c7d49f8f14a04397117ddec7 | [] | no_license | DRG-Modding/Header-Dumps | 763c7195b9fb24a108d7d933193838d736f9f494 | 84932dc1491811e9872b1de4f92759616f9fa565 | refs/heads/main | 2023-06-25T11:11:10.298500 | 2023-06-20T13:52:18 | 2023-06-20T13:52:18 | 399,652,576 | 8 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 889 | hpp | #ifndef UE4SS_SDK_BP_TikiTorch_HPP
#define UE4SS_SDK_BP_TikiTorch_HPP
class ABP_TikiTorch_C : public AActor
{
FPointerToUberGraphFrame UberGraphFrame;
class UBoxComponent* Box;
class UAudioComponent* audio;
class UNiagaraComponent* NS_TikiTorch_Light_Flicker;
class UNiagaraComponent* NS_Fire_TikiTorch;
class UPointLightComponent* Light_FireFlicker;
class UStaticMeshComponent* SM_TikiTorch;
class USceneComponent* Scene;
FLinearColor Light Color;
float Light Intensity;
float Light Attenuation;
TArray<class UStaticMesh*> Mesh;
int32 Mesh to use;
float MaterialGlow;
bool Flicker;
int32 TimesToFlash;
bool Casts Shadows;
FVector Light Offset;
class UMaterialInstanceDynamic* DynamicMaterial;
bool NewVar_0;
void ReceiveBeginPlay();
void ExecuteUbergraph_BP_TikiTorch(int32 EntryPoint);
};
#endif
| [
"bobby45900@gmail.com"
] | bobby45900@gmail.com |
9d3354dd03636f0d7b5a24182c54cdb72b064759 | 1721779a4625ea06c43844a617b0d418ab4c567b | /HelloWorld/HelloWorld/Scene.h | 4f33b9478f7b51f5f08d5d43c3cc1aeb2cb932af | [] | no_license | ajiethv/relict | c40101ce4e5cb906534dae0b259b01ac084d4666 | 048fece3b3d18bd6d71a8cc6cf96486ab5a55d6f | refs/heads/master | 2020-12-13T13:13:40.310509 | 2020-04-04T03:44:57 | 2020-04-04T03:44:57 | 234,427,076 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,452 | h | #ifndef __SCENE_H__
#define __SCENE_H__
#include "JSON.h"
#include "ECS.h"
class Scene
{
public:
Scene() { m_sceneReg = new entt::registry(); }
Scene(std::string name);
~Scene() { }
void Unload();
//Each scene will need to have a different
//init, as each scene's contents will be different
virtual void InitScene(float windowWidth, float windowHeight) { printf("windowwidth: %f, windowHeight: %f", windowWidth, windowHeight); };
//Saves the scene
void SaveScene();
//Get the scene registry
entt::registry* GetScene() const;
//Set the scene registry
void SetScene(entt::registry& scene);
std::string GetName() const;
void SetName(std::string name);
//Set window size (makes sure the camera aspect is proper)
void SetWindowSize(float windowWidth, float windowHeight);
protected:
entt::registry* m_sceneReg = nullptr;
std::string m_name = "Default Name";
};
#ifndef __SCENEJSON_H__
#define __SCENEJSON_H__
//Sends animation TO json file
inline void to_json(nlohmann::json& j, const Scene& scene)
{
j["SceneName"] = scene.GetName();
auto view = scene.GetScene()->view<EntityIdentifier>();
//keeps count of how many entities were stored
unsigned int counter = 0;
for (auto entity : view)
{
//Stores the entity identifier
j[std::to_string(counter)]["Identifier"] = view.get(entity);
//Identifier used to check what components are within this entity
unsigned int identity = view.get(entity).GetIdentifier();
//If Identity includes the Camera bit
//This means the entity contains a camera
if (identity & EntityIdentifier::CameraBit())
{
//Stores the camera
j[std::to_string(counter)]["Camera"] = scene.GetScene()->get<Camera>(entity);
}
//If Identity includes the Sprite bit
//This means the entity contains a Sprite
if (identity & EntityIdentifier::SpriteBit())
{
//Stores the sprite
j[std::to_string(counter)]["Sprite"] = scene.GetScene()->get<Sprite>(entity);
}
//If Identity includes the Animation Controller bit
//This means that the entity contains an Animation Controller
if (identity & EntityIdentifier::AnimationBit())
{
//Stores the Animation controllers
j[std::to_string(counter)]["AnimationController"] = scene.GetScene()->get<AnimationController>(entity);
}
//If Identity includes the Transform bit
//This means that the entity contains a Transform
if (identity & EntityIdentifier::TransformBit())
{
//Stores the transform
j[std::to_string(counter)]["Transform"] = scene.GetScene()->get<Transform>(entity);
}
//If you create new classes that you add as a component,
//you need to #1 add a static (unique) bit for that class
//And then add more if statements after this point
if (identity & EntityIdentifier::StatsBit())
{
j[std::to_string(counter)]["Stats"] = scene.GetScene()->get<Stats>(entity);
}
if (identity & EntityIdentifier::HoriScrollCameraBit())
{
j[std::to_string(counter)]["HoriScrollCam"] = scene.GetScene()->get<HorizontalScroll>(entity);
}
if (identity & EntityIdentifier::VertiScrollCameraBit())
{
j[std::to_string(counter)]["VertiScrollCam"] = scene.GetScene()->get<VerticalScroll>(entity);
}
if (identity & EntityIdentifier::BulletBit())
{
j[std::to_string(counter)]["Bullet"] = scene.GetScene()->get<Bullet>(entity);
}
if (identity & EntityIdentifier::EnemyBit())
{
j[std::to_string(counter)]["Enemy"] = scene.GetScene()->get<Enemy>(entity);
}
//For each loop increase the counter
counter++;
}
//Stores the number of entities (for your loops)
j["NumEntities"] = counter;
}
//Reads animation in FROM json file
inline void from_json(const nlohmann::json& j, Scene& scene)
{
//Stores number of entities
unsigned int numEntities = j["Scene"]["NumEntities"];
//Sets the scene name (so you can save over the same file)
scene.SetName(j["Scene"]["SceneName"]);
//Reference to the registry
auto ® = *scene.GetScene();
bool scrollHori = false;
bool scrollVerti = false;
//Allows you to create each entity
for (unsigned i = 0; i < numEntities; i++)
{
//Has animation
bool hasAnim = false;
//Creates new entity
auto entity = reg.create();
reg.assign<EntityIdentifier>(entity);
//Sets the entity identifier correctly
reg.get<EntityIdentifier>(entity) = j["Scene"][std::to_string(i)]["Identifier"];
reg.get<EntityIdentifier>(entity).SetEntity(entity);
//Just check if this entity is the main camera
if (reg.get<EntityIdentifier>(entity).GetIsMainCamera())
{
//Sets main camera
EntityIdentifier::MainCamera(entity);
}
if (reg.get<EntityIdentifier>(entity).GetIsMainPlayer())
{
//Sets main player
EntityIdentifier::MainPlayer(entity);
}
unsigned int identity = reg.get<EntityIdentifier>(entity).GetIdentifier();
//If Identity includes the Camera bit
//This means the entity contains a camera
if (identity & EntityIdentifier::CameraBit())
{
//Adds camera to the entity
reg.assign<Camera>(entity);
//Sets the camera to the saved version
reg.get<Camera>(entity) = j["Scene"][std::to_string(i)]["Camera"];
}
//If Identity includes the Animation Controller bit
//This means that the entity contains an Animation Controller
if (identity & EntityIdentifier::AnimationBit())
{
//Adds Animation Controller to the entity
reg.assign<AnimationController>(entity);
//Sets the Animation Controller to the saved version
reg.get<AnimationController>(entity) = j["Scene"][std::to_string(i)]["AnimationController"];
hasAnim = true;
//Animation controllers requires that we init the UVs with the filename
reg.get<AnimationController>(entity).InitUVs(reg.get<AnimationController>(entity).GetFileName());
}
//If Identity includes the Sprite bit
//This means the entity contains a Sprite
if (identity & EntityIdentifier::SpriteBit())
{
AnimationController* anim = nullptr;
if (hasAnim)
anim = ®.get<AnimationController>(entity);
//Adds sprite to the entity
reg.assign<Sprite>(entity);
//Sets the sprite to the saved version
reg.get<Sprite>(entity) = j["Scene"][std::to_string(i)]["Sprite"];
//Sprite requires that we load in the sprite
std::string fileName = reg.get<Sprite>(entity).GetFileName();
reg.get<Sprite>(entity).LoadSprite(fileName, reg.get<Sprite>(entity).GetWidth(), reg.get<Sprite>(entity).GetHeight(), hasAnim, anim);
if (reg.get<Sprite>(entity).GetIsSpriteSheet())
{
reg.get<Sprite>(entity).SetUVs(reg.get<Sprite>(entity).GetBottomLeft(), reg.get<Sprite>(entity).GetTopRight());
}
}
//If Identity includes the Transform bit
//This means that the entity contains a Transform
if (identity & EntityIdentifier::TransformBit())
{
//Adds transform to the entity
reg.assign<Transform>(entity);
//Sets the transform to the saved version
reg.get<Transform>(entity) = j["Scene"][std::to_string(i)]["Transform"];
//Transforms require no further initialization
}
if (identity & EntityIdentifier::StatsBit()) {
reg.assign<Stats>(entity);
reg.get<Stats>(entity) = j["Scene"][std::to_string(i)]["Stats"];
}
if (identity & EntityIdentifier::HoriScrollCameraBit())
{
reg.assign<HorizontalScroll>(entity);
reg.get<HorizontalScroll>(entity) = j["Scene"][std::to_string(i)]["HoriScrollCam"];
scrollHori = true;
}
if (identity & EntityIdentifier::VertiScrollCameraBit())
{
reg.assign<VerticalScroll>(entity);
reg.get<VerticalScroll>(entity) = j["Scene"][std::to_string(i)]["VertiScrollCam"];
scrollVerti = true;
}
if (identity & EntityIdentifier::BulletBit())
{
reg.assign<Bullet>(entity);
reg.get<Bullet>(entity) = j["Scene"][std::to_string(i)]["Bullet"];
}
if (identity & EntityIdentifier::EnemyBit())
{
reg.assign<Enemy>(entity);
reg.get<Enemy>(entity) = j["Scene"][std::to_string(i)]["Enemy"];
}
}
if (scrollHori)
{
reg.get<HorizontalScroll>(EntityIdentifier::MainCamera()).SetCam(®.get<Camera>(EntityIdentifier::MainCamera()));
reg.get<HorizontalScroll>(EntityIdentifier::MainCamera()).SetFocus(®.get<Transform>(EntityIdentifier::MainPlayer()));
}
if (scrollVerti)
{
reg.get<VerticalScroll>(EntityIdentifier::MainCamera()).SetCam(®.get<Camera>(EntityIdentifier::MainCamera()));
reg.get<VerticalScroll>(EntityIdentifier::MainCamera()).SetFocus(®.get<Transform>(EntityIdentifier::MainPlayer()));
}
}
#endif // !__TRANSFORMJSON_H__
#endif // !__SCENE_H__
| [
"keaton.pledge@ontariotechu.net"
] | keaton.pledge@ontariotechu.net |
e2ecb2b9db1f11129825434c799545480b708bc0 | 810fcadbb217b1e7fd58c68f576ca205218ab1e7 | /Media/VoIP/Nequeo.Sip/Nequeo.PjSip-v2.5.5/Nequeo.PjSip/OnCallStateParam.cpp | f46d6402e29a420ab87d147c0a7a938b16014583 | [
"MIT"
] | permissive | drazenzadravec/projects | ac0706d67de944b6ac5cd74798e3af3588446c0d | 8b7f1653c70c2104462b8c1660175caf96e80885 | refs/heads/master | 2021-08-10T21:42:26.366786 | 2021-01-02T03:57:29 | 2021-01-02T03:57:29 | 56,288,488 | 5 | 4 | MIT | 2020-07-07T03:52:39 | 2016-04-15T03:34:33 | JavaScript | WINDOWS-1252 | C++ | false | false | 2,285 | cpp | /* Company : Nequeo Pty Ltd, http://www.nequeo.com.au/
* Copyright : Copyright © Nequeo Pty Ltd 2015 http://www.nequeo.com.au/
*
* File : OnCallStateParam.cpp
* Purpose : SIP OnCallStateParam class.
*
*/
/*
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.
*/
#include "stdafx.h"
#include "OnCallStateParam.h"
using namespace Nequeo::Net::PjSip;
/// <summary>
/// On call state paramters.
/// </summary>
OnCallStateParam::OnCallStateParam()
{
}
/// <summary>
/// Gets or sets the current call.
/// </summary>
Call^ OnCallStateParam::CurrentCall::get()
{
return _currentCall;
}
/// <summary>
/// Gets or sets the current call.
/// </summary>
void OnCallStateParam::CurrentCall::set(Call^ value)
{
_currentCall = value;
}
/// <summary>
/// Gets or sets the call information.
/// </summary>
CallInfo^ OnCallStateParam::Info::get()
{
return _info;
}
/// <summary>
/// Gets or sets the call information.
/// </summary>
void OnCallStateParam::Info::set(CallInfo^ value)
{
_info = value;
}
/// <summary>
/// Gets or sets the sip event type.
/// </summary>
SipEventType OnCallStateParam::EventType::get()
{
return _eventType;
}
/// <summary>
/// Gets or sets the sip event type.
/// </summary>
void OnCallStateParam::EventType::set(SipEventType value)
{
_eventType = value;
} | [
"drazenzadravec@live.com.au"
] | drazenzadravec@live.com.au |
211fe9462b08563cd8e388b5318dd2fcffc455fd | 28a554599ba006dbc76442bc48e48e49848d2ddc | /src/canvas.cpp | a89e7e1e53234a4ab39e0fa386312179407f16d3 | [] | no_license | ArthurGoodman/dragon | a81d5bcd3256204b5d78bb35fa06780a7df6071a | 9370d4261fd097aa070359c868ea6c4c77dcadb1 | refs/heads/master | 2021-01-19T00:14:07.358306 | 2016-06-30T18:38:59 | 2016-06-30T18:38:59 | 62,333,488 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 199 | cpp | #include "canvas.h"
Canvas::~Canvas() {
}
void Canvas::setPixel(int x, int y, const Color &color) {
setPixel(x, y, color.rgba());
}
Size Canvas::size() {
return Size(width(), height());
}
| [
"arthur.goodman3@gmail.com"
] | arthur.goodman3@gmail.com |
56bcdcaa64270e64654669edd2445053714d1540 | 452b514ce0fae960b863464ac3b2eba2732abc8c | /software/GUI/WAG_bands/networkmonitor.h | 5326f29fb4168b59e82b5a8c60bedd08056b14cc | [] | no_license | fangedscorpion/suitup_WPI_MQP | 1e699e41d6e04bc67cb4c2ce9562a685f82fbc6a | 3606388b0fb30f02c50850fb7e48ce4575d1737c | refs/heads/master | 2021-03-24T12:30:02.021904 | 2016-04-23T02:19:51 | 2016-04-23T02:19:51 | 41,758,265 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 489 | h | #ifndef NETWORKMONITOR_H
#define NETWORKMONITOR_H
#include <QQuaternion>
#include <QString>
class NetworkMonitor
{
public:
NetworkMonitor(int portNumber);
~NetworkMonitor();
signals:
void receievedQuaternion(QQuaternion quat);
void acceptedConnection(QString ipAddress);
public slots:
void sendMotorCommand();
private:
int clntSocket;
int recieveData(char *dataBuffer);
void sendData(char * serializedData, int dataLen);
};
#endif // NETWORKMONITOR_H
| [
"mandi1267@gmail.com"
] | mandi1267@gmail.com |
c366b2998b1aa1f1a2f00e7e6e99cfb4694a79fe | f81b774e5306ac01d2c6c1289d9e01b5264aae70 | /content/renderer/worker/dedicated_worker_host_factory_client.h | 315b6582285f160a4eef052ffb82b137ee0435ae | [
"BSD-3-Clause"
] | permissive | waaberi/chromium | a4015160d8460233b33fe1304e8fd9960a3650a9 | 6549065bd785179608f7b8828da403f3ca5f7aab | refs/heads/master | 2022-12-13T03:09:16.887475 | 2020-09-05T20:29:36 | 2020-09-05T20:29:36 | 293,153,821 | 1 | 1 | BSD-3-Clause | 2020-09-05T21:02:50 | 2020-09-05T21:02:49 | null | UTF-8 | C++ | false | false | 4,440 | 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 CONTENT_RENDERER_WORKER_DEDICATED_WORKER_HOST_FACTORY_CLIENT_H_
#define CONTENT_RENDERER_WORKER_DEDICATED_WORKER_HOST_FACTORY_CLIENT_H_
#include <memory>
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/blink/public/common/browser_interface_broker_proxy.h"
#include "third_party/blink/public/mojom/loader/resource_load_info_notifier.mojom.h"
#include "third_party/blink/public/mojom/renderer_preference_watcher.mojom-forward.h"
#include "third_party/blink/public/mojom/renderer_preferences.mojom-forward.h"
#include "third_party/blink/public/mojom/worker/dedicated_worker_host_factory.mojom.h"
#include "third_party/blink/public/platform/web_dedicated_worker_host_factory_client.h"
namespace blink {
class WebDedicatedWorker;
class WebWorkerFetchContext;
} // namespace blink
namespace content {
class ChildURLLoaderFactoryBundle;
class ServiceWorkerProviderContext;
class WebWorkerFetchContextImpl;
// DedicatedWorkerHostFactoryClient intermediates between
// blink::(Web)DedicatedWorker and content::DedicatedWorkerHostFactory. This
// is bound with the thread where the execution context creating this worker
// lives (i.e., the main thread or a worker thread for nested workers). This is
// owned by blink::(Web)DedicatedWorker.
class DedicatedWorkerHostFactoryClient final
: public blink::WebDedicatedWorkerHostFactoryClient,
public blink::mojom::DedicatedWorkerHostFactoryClient {
public:
DedicatedWorkerHostFactoryClient(
blink::WebDedicatedWorker* worker,
const blink::BrowserInterfaceBrokerProxy& interface_broker);
~DedicatedWorkerHostFactoryClient() override;
// Implements blink::WebDedicatedWorkerHostFactoryClient.
void CreateWorkerHostDeprecated(
const blink::DedicatedWorkerToken& dedicated_worker_token,
base::OnceCallback<void(const network::CrossOriginEmbedderPolicy&)>
callback) override;
void CreateWorkerHost(
const blink::DedicatedWorkerToken& dedicated_worker_token,
const blink::WebURL& script_url,
network::mojom::CredentialsMode credentials_mode,
const blink::WebFetchClientSettingsObject& fetch_client_settings_object,
blink::CrossVariantMojoRemote<blink::mojom::BlobURLTokenInterfaceBase>
blob_url_token) override;
scoped_refptr<blink::WebWorkerFetchContext> CloneWorkerFetchContext(
blink::WebWorkerFetchContext* web_worker_fetch_context,
scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
scoped_refptr<WebWorkerFetchContextImpl> CreateWorkerFetchContext(
blink::mojom::RendererPreferences renderer_preference,
mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
watcher_receiver,
mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
pending_resource_load_info_notifier);
private:
// Implements blink::mojom::DedicatedWorkerHostFactoryClient.
void OnWorkerHostCreated(
mojo::PendingRemote<blink::mojom::BrowserInterfaceBroker>
browser_interface_broker) override;
void OnScriptLoadStarted(
blink::mojom::ServiceWorkerContainerInfoForClientPtr
service_worker_container_info,
blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
std::unique_ptr<blink::PendingURLLoaderFactoryBundle>
pending_subresource_loader_factory_bundle,
mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
subresource_loader_updater,
blink::mojom::ControllerServiceWorkerInfoPtr controller_info) override;
void OnScriptLoadStartFailed() override;
// |worker_| owns |this|.
blink::WebDedicatedWorker* worker_;
scoped_refptr<ChildURLLoaderFactoryBundle> subresource_loader_factory_bundle_;
mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
pending_subresource_loader_updater_;
scoped_refptr<ServiceWorkerProviderContext> service_worker_provider_context_;
mojo::Remote<blink::mojom::DedicatedWorkerHostFactory> factory_;
mojo::Receiver<blink::mojom::DedicatedWorkerHostFactoryClient> receiver_{
this};
};
} // namespace content
#endif // CONTENT_RENDERER_WORKER_DEDICATED_WORKER_HOST_FACTORY_CLIENT_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
16716a88aeb4ac7fe3a0775f6ced8c035ea21485 | c217a840e32d17f8aa31efd4c34b2d87a1db76eb | /framework/Physics/Base/Mass.cpp | 14baff3848611555125802d0d1d179fa3e8f6038 | [] | no_license | eleveeeen/physics | 1df794859965b1041cbad7b644aa944b6354b61d | 09bb4588237d4dfc7e802848846dbb2302b8907b | refs/heads/master | 2020-03-19T21:33:51.907078 | 2018-06-11T16:01:27 | 2018-06-11T16:01:27 | 136,942,988 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 1,872 | cpp | #include"Mass.h"
#include"../../Utility/GameMath.h"
namespace CalcMass
{
D3DXMATRIX InertiaBox(const D3DXVECTOR3& halfExtent, float mass)
{
D3DXVECTOR3 sqrSz = halfExtent*2.0f;
sqrSz = GameMath::MulPerElem(sqrSz, sqrSz);
D3DXMATRIX inertia = GameMath::IdentityMatrix();
inertia._11 = (mass*(sqrSz[1] + sqrSz[2])) / 12.0f;
inertia._22 = (mass*(sqrSz[0] + sqrSz[2])) / 12.0f;
inertia._33 = (mass*(sqrSz[0] + sqrSz[1])) / 12.0f;
return inertia;
}
D3DXMATRIX InertiaSphere(float radius, float mass)
{
D3DXMATRIX inertia = GameMath::IdentityMatrix();
inertia._11 = inertia._22 = inertia._33 = 0.4f * mass * radius * radius;
return inertia;
}
static inline D3DXMATRIX InertiaCylinder(float halfLength, float radius, float mass, int axis)
{
D3DXMATRIX inertia = GameMath::IdentityMatrix();
inertia._11 = inertia._22 = inertia._33 = mass / 12.0f * (3.0f * radius * radius + 4.0f * halfLength * halfLength);
inertia.m[axis][axis] = 0.5f * mass * radius *radius;
return inertia;
}
D3DXMATRIX InertiaCylinderX(float halfLength, float radius, float mass)
{
return InertiaCylinder(halfLength, radius, mass, 0);
}
D3DXMATRIX InertiaCylinderY(float halfLength, float radius, float mass)
{
return InertiaCylinder(halfLength, radius, mass, 1);
}
D3DXMATRIX InertiaCylinderZ(float halfLength, float radius, float mass)
{
return InertiaCylinder(halfLength, radius, mass, 2);
}
//質量の移動、回転、合成
D3DXMATRIX Translate(float mass, const D3DXMATRIX& inertia, const D3DXVECTOR3& translation)
{
D3DXMATRIX m = GameMath::CrossMatrix(translation);
return GameMath::Add3x3(inertia, mass * (m*-m));
}
D3DXMATRIX Rotate(const D3DXMATRIX& inertia, const D3DXMATRIX& rotate)
{
return GameMath::Transpose3x3(rotate) * inertia * rotate;
}
}; | [
"noreply@github.com"
] | noreply@github.com |
7204f11d84bdbaf6490f85f1756e1322479e7aa5 | 0bfe65241a94cc91a3ebcc22fe2f39ebba111a4d | /Weapon.h | 429e0fdf60777b28fd0a55f270b76609a4a62f3b | [] | no_license | travijuu/TeamTwo | cb541a0056ea4db47b6d2f75deaf2576461d391d | 78ce425994901c564fff4e94fda0f2914c7db57d | refs/heads/master | 2016-09-05T18:13:58.504747 | 2013-12-04T17:42:07 | 2013-12-04T17:42:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,694 | h | /*
Copyright (C) 2011-2012 Alican Sekerefe
TeamTwo 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.
TeamTwo 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/>.
Contact: projectteamtwo@gmail.com
*/
#ifndef WEAPON_H
#define WEAPON_H
#include "stdafx.h"
#include "Bullet.h"
#include "AnimationController.h"
#include "ItemStructure.h"
#include "Util/Logger.h"
namespace WeaponSlot
{
enum WeaponSlots
{
Primary=0,
Secondary,
Tertiary,
Quaternary,
Quinary,
None
};
}
/* Weapon class
This class is responsible for providing
common attributes of a weapon such as
its bullet speed, muzzle flashes and etc.
Weapon cannot be used by itself, instead
it has to be inherited by another class
in order to utilize from it.
*/
class Weapon
{
public:
//constructor of the class. requires the owner id of the weapon
//weapon's type and team
Weapon(int ownerID,int weaponType,unsigned char team);
//destructor of the class.
~Weapon()
{
Logger::getSingleton()->addLine("Weapon: deleting weapon");
delete fireTimer;
delete reloadTimer;
Logger::getSingleton()->addLine("Weapon: weapon deleted");
}
//returns muzzleflash node
SceneNode* getMuzzleFlashNode();
//updates the weapon's graphics, reload timers etc.
void update();
//starts a timer to reload the weapon
void reload();
//fires the weapon, starts a timer to calculate the next fire
void fire();
//returns the ammo count on the current clip
int getClipAmmo();
//returns the number of clips the weapon has
int getClipCount();
//returns the ammo capacity of the weapon's clip
int getClipSize();
//returns the weaponslot which the weapon object belongs
int getWeaponSlot();
//returns the maximum ammo that the weapon can have
int getMaxClip();
//returns the type of the weapon
int getWeaponType();
//returns the total ammo that the weapon has
int getTotalAmmo();
//returns true if the weapon can fire, considers the previous reload and fire actions
bool canFire();
//returns true if weapon can be reloaded. cosiders the previous reload action
bool canReload();
//returns true if the weapon can be added extra clips
bool canTakeClips();
//adds the given number of clips to the weapon
void addClip(int count);
//enables ammunition check. in this case fire() and canFire() will return variying results
//enabled by default
void enableAmmunitionCheck();
//disables ammunition check for the weapon. weapon will always be able to fire without
//checking the ammunition
void disableAmmunitionCheck();
//shows the weapon and its sub objects
void show();
//hides the weapon and its sub objects
void hide();
//sets the number of ammo that the clips has
void setClipAmmo(int ammo);
//returns the AnimationController object for the weapon
AnimationController* getAnimationController();
//retunrs the weapon' node
Ogre::SceneNode* getWeaponNode();
//returns the weapon' entity
Ogre::Entity* getWeaponEntity();
//returns the weapon's light object
Ogre::Light* getWeaponLight();
//sets a SceneNode for the weapon
void setSceneNode(Ogre::SceneNode* weaponNode);
//returns the bullet origin of the weapon
Ogre::Vector3 getBulletOrigin();
//zeros the clip and ammo count of the weapon. useful for reinitializing
void zero();
//creates bullet
virtual Bullet* createBullet(SceneManager* sceneManager,OgreBulletDynamics::DynamicsWorld* dynamics, Ogre::Vector3 position, Ogre::Quaternion orientation)=0;
//creates bullet
virtual Bullet* createBullet(SceneManager* sceneManager,OgreBulletDynamics::DynamicsWorld* dynamics, Ogre::Quaternion orientation){return NULL;}
//creates visual of the weapon
virtual void createVisual(SceneManager* sceneManager, SceneNode* playerNode)=0;
//changes the necessary colors of the weapon
virtual void changeColor(unsigned char color)=0;
private:
//initializes the weapon. must be implemented by the derived class
virtual void initialize()=0;
bool justFired;
int visualizationEndFrame;
int visualizationCurrentFrame;
bool fireVisualized;
protected:
std::string name;
int ownerID;
unsigned char team;
int totalAmmo;
int clipAmmo;
int clipCount;
int clipSize;
int maxClip;
int roundsPerSecond;
int weaponSlot;
int weaponType;
long nextFireTime;
long reloadDuration;
long reloadEndTime;
bool reloading;
bool fired;
bool check;
bool local;
Entity* bulletEntity;
AnimationController* animationController;
Ogre::Vector3 bulletOrigin;
Ogre::Timer* fireTimer;
Ogre::Timer* reloadTimer;
SceneNode* playerNode;
SceneNode* weaponNode;
SceneNode* muzzleFlashNode;
Entity* weaponEntity;
Entity* muzzleFlashEntity;
Light* weaponLight;
unsigned char color;
std::string fireSoundID;
std::vector<std::string> reloadSoundIDs;
};
#endif /* WEAPON_H */
| [
"travijuu@gmail.com"
] | travijuu@gmail.com |
bfa7f364afca144dbf65742a2dd91ac83b4e1454 | e6cf89bafc571f7bcf78b81a90acfb3616f7aa52 | /Servants/servantberserkeraxe.h | bee4b603a6c150e7f3ea34f4a70eb9c9059323ef | [] | no_license | matathias/Fate-Battle | 4770c364026bd13a2d4169508532b0c40fecdf41 | 8c0865a794e2783ef4659802da7af710fe648ea5 | refs/heads/master | 2021-01-21T04:44:37.152704 | 2018-03-16T22:34:06 | 2018-03-16T22:34:06 | 55,940,174 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 718 | h | #ifndef SERVANTBERSERKERAXE_H
#define SERVANTBERSERKERAXE_H
#pragma once
#include "Servants/servantberserker.h"
class ServantBerserkerAxe : public ServantBerserker
{
public:
ServantBerserkerAxe(int as, Team t, Logger *l);
virtual bool isGodmindActive();
virtual void turnUpdate();
virtual int doAction(int actionNum, vector<Servant *> defenders);
virtual int attack(vector<Servant *> defenders, bool counter);
int extendGodmind();
virtual void subHP(int hp, DamageType dt);
virtual void setHP(int hp);
protected:
bool isGodmindExtended();
int godmindTurnsLeft();
int deathCount;
int deathCeiling;
int numDamageFreeTurns;
};
#endif // SERVANTBERSERKERAXE_H
| [
"warrick.david58@gmail.com"
] | warrick.david58@gmail.com |
369d5139b206d8f5cd3711d609b8d696f9410dff | 03d1b64947c22b1418ac09b3e2d39786f6b57f62 | /include/sp2/scene/node.h | bce3952df6d89d3eef9a9f1d44dee59734c10260 | [] | no_license | croxis/SeriousProton2 | e2a1b0156e5a611ec76bb97788e389f135c114ea | f034b8ecae5f6ea63bd93afa2e0aaecf6b74ddba | refs/heads/master | 2020-07-25T14:10:51.320418 | 2019-09-12T18:51:53 | 2019-09-12T18:51:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,033 | h | #ifndef SP2_SCENE_NODE_H
#define SP2_SCENE_NODE_H
#include <sp2/math/matrix4x4.h>
#include <sp2/math/quaternion.h>
#include <sp2/script/bindingObject.h>
#include <sp2/pointerList.h>
#include <sp2/graphics/scene/renderdata.h>
#include <sp2/graphics/animation.h>
#include <sp2/multiplayer/replication.h>
class b2Body;
class btRigidBody;
namespace sp {
namespace multiplayer {
class Server;
class Client;
}
namespace collision {
class Backend;
class Shape;
class Joint2D;
}
class Node;
class CollisionInfo
{
public:
P<Node> other;
float force;
sp::Vector2d position;
sp::Vector2d normal;
};
class Scene;
class RenderData;
class Node : public ScriptBindingObject
{
public:
Node(P<Node> parent);
virtual ~Node();
P<Node> getParent();
P<Scene> getScene();
const PList<Node>& getChildren();
void setParent(P<Node> new_parent);
void setPosition(Vector2d position);
void setPosition(Vector3d position);
void setRotation(double rotation);
void setRotation(Quaterniond rotation);
void setLinearVelocity(Vector2d velocity);
void setLinearVelocity(Vector3d velocity);
void setAngularVelocity(double velocity);
void setAngularVelocity(Vector3d velocity);
Vector2d getPosition2D();
double getRotation2D();
Vector2d getLocalPoint2D(Vector2d v);
Vector2d getGlobalPosition2D();
double getGlobalRotation2D();
Vector2d getGlobalPoint2D(Vector2d v);
Vector2d getLinearVelocity2D();
double getAngularVelocity2D();
Vector3d getPosition3D();
Quaterniond getRotation3D();
Vector3d getGlobalPosition3D();
Vector3d getGlobalPoint3D(Vector3d v);
Vector3d getLinearVelocity3D();
Vector3d getAngularVelocity3D();
const Matrix4x4f& getGlobalTransform() const { return global_transform; }
const Matrix4x4f& getLocalTransform() const { return local_transform; }
//Set or replace the current collision shape on this body.
//If you want to shape change, you do not need to call removeCollisionShape() before calling setCollisionShape (doing so will reset the velocity)
void setCollisionShape(const collision::Shape& shape);
//Remove the collision shape.
void removeCollisionShape();
//Test if the given point will collide with the shape of this Node.
bool testCollision(sp::Vector2d position);
//Test if this is a solid object, so it has a collision shape, which isn't generated as Sensor.
bool isSolid();
void setAnimation(std::unique_ptr<Animation> animation);
void animationPlay(string key, float speed=1.0);
void animationSetFlags(int flags);
int animationGetFlags();
bool animationIsFinished();
//Event called every frame.
//The delta is the time in seconds passed sinds the previous frame, multiplied by the global game speed.
//Called when the game is paused with delta = 0
virtual void onUpdate(float delta) {}
//Event called 30 times per second. Not called when the game is paused.
virtual void onFixedUpdate() {}
//Event called when 2 nodes collide. Not called when the game is paused.
virtual void onCollision(CollisionInfo& info) {}
RenderData render_data;
class Multiplayer
{
public:
Multiplayer(Node* node);
~Multiplayer();
void enable();
bool isEnabled();
void enableDeadReckoning(const multiplayer::DeadReckoningConfig& config)
{
replication_links.push_back(new multiplayer::ReplicationDeadReckoning(*node, config));
}
template<typename T> void replicate(T& var)
{
replication_links.push_back(new multiplayer::ReplicationLink<T>(var));
}
template<typename T> void replicate(T& var, float max_update_interval)
{
replication_links.push_back(new multiplayer::ReplicationLink<T>(var, max_update_interval));
}
template<typename T, typename... ARGS> void addReplicationLink(ARGS&... args)
{
replication_links.push_back(new T(args...));
}
template<typename CLASS, typename... ARGS> void replicate(void(CLASS::*func)(ARGS...))
{
replication_calls.push_back(new multiplayer::ReplicationCallInfo<CLASS, ARGS...>(func));
}
template<typename CLASS, typename... ARGS> void callOnServer(void(CLASS::*func)(ARGS...), ARGS... args)
{
for(unsigned int n=0; n<replication_calls.size(); n++)
{
if (replication_calls[n]->getPtr() == multiplayer::ReplicationCallInfoBase::ReplicationCallInfoBase::BaseFuncPtr(func))
{
prepared_calls.emplace_back(uint16_t(n), args...);
return;
}
}
}
uint64_t getId() const
{
return id;
}
private:
Node* node;
bool enabled;
uint64_t id;
std::vector<multiplayer::ReplicationLinkBase*> replication_links;
std::vector<multiplayer::ReplicationCallInfoBase*> replication_calls;
std::vector<io::DataBuffer> prepared_calls;
friend class ::sp::multiplayer::Server;
friend class ::sp::multiplayer::Client;
} multiplayer;
private:
Node(Scene* scene);
P<Scene> scene;
P<Node> parent;
PList<Node> children;
void* collision_body = nullptr;
Vector3d translation;
Quaterniond rotation;
Matrix4x4f global_transform;
Matrix4x4f local_transform;
std::unique_ptr<Animation> animation;
void updateLocalTransform();
void updateGlobalTransform();
void modifyPositionByPhysics(sp::Vector2d position, double rotation);
void modifyPositionByPhysics(sp::Vector3d position, Quaterniond rotation);
friend class Scene;
friend class collision::Shape;
friend class collision::Backend;
friend class collision::Joint2D;
};
};//namespace sp
#endif//SP2_SCENE_NODE_H
| [
"daid303@gmail.com"
] | daid303@gmail.com |
ad56ac26ee676cde2220cf62b41aebb0a30b5ab8 | b0ee03926ee77ebe1bbfe0e619a56eeae837bde1 | /Online-Judge-Solutions/SPOJ/GSS2 - Can you answer these queries II.cpp | 4105d1b9f73989cdcd64c542b71d55119ae9afb3 | [] | no_license | artugal28373/CompetitveProgramming | 6457a44f03cf3b62c2cdb832dcd7ee4c95d272a3 | e41e1b7ea46ab4088ef487bf00ab0aad7dc06ef9 | refs/heads/master | 2022-04-10T11:15:19.804675 | 2019-09-30T20:35:03 | 2019-09-30T20:35:03 | 476,767,051 | 1 | 0 | null | 2022-04-01T15:07:20 | 2022-04-01T15:07:19 | null | UTF-8 | C++ | false | false | 5,419 | cpp | /*
Hint : https://www.quora.com/How-can-the-SPOJ-problem-GSS2-be-solved/answer/Brian-Bi?srid=29u8
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pii pair <int,int>
#define pll pair <long long,long long>
#define sc scanf
#define pf printf
#define Pi 2*acos(0.0)
#define ms(a,b) memset(a, b, sizeof(a))
#define pb(a) push_back(a)
#define MP make_pair
#define db double
#define ll long long
#define EPS 10E-10
#define ff first
#define ss second
#define sqr(x) (x)*(x)
#define D(x) cerr<<#x " = "<<(x)<<endl
#define VI vector <int>
#define DBG pf("Hi\n")
#define MOD 1000000007
#define CIN ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a) (int)a.size()
#define sf(a) scanf("%d",&a)
#define sfl(a) scanf("%lld",&a)
#define sff(a,b) scanf("%d %d",&a,&b)
#define sffl(a,b) scanf("%lld %lld",&a,&b)
#define sfff(a,b,c) scanf("%d %d %d",&a,&b,&c)
#define sfffl(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define stlloop(v) for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n) for(int i=0;i<n;i++)
#define loop1(i,n) for(int i=1;i<=n;i++)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define RREP(i,a,b) for(int i=a;i>=b;i--)
#define TEST_CASE(t) for(int z=1;z<=t;z++)
#define PRINT_CASE printf("Case %d: ",z)
#define LINE_PRINT_CASE printf("Case %d:\n",z)
#define CASE_PRINT cout<<"Case "<<z<<": "
#define all(a) a.begin(),a.end()
#define intlim 2147483648
#define infinity (1<<28)
#define ull unsigned long long
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a)*((b)/gcd(a,b)))
using namespace std;
//using namespace __gnu_pbds;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
//const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
//const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*------------------------------------------------*/
/*-----------------------Bitmask------------------*/
//int Set(int N,int pos){return N=N | (1<<pos);}
//int reset(int N,int pos){return N= N & ~(1<<pos);}
//bool check(int N,int pos){return (bool)(N & (1<<pos));}
/*------------------------------------------------*/
#define mx 100005
#define segment_tree int l=n*2,r=l+1,mid=(b+e)/2
int ara[mx+5];
int last[2*mx+5];
ll ans[mx+5];
struct data
{
int l,r,id;
};
vector<data>queries;
struct data1
{
ll sum,lazy,best_lazy,ans;
data1()
{
sum=lazy=best_lazy=ans=0;
}
};
data1 tree[3*mx];
void push_down(data1 &cur, data1 &lft, data1 &rgt)
{
// if(cur.lazy || cur.best_lazy)
// {
lft.best_lazy=max(lft.best_lazy,lft.lazy+cur.best_lazy);
lft.lazy+=cur.lazy;
lft.ans=max(lft.ans,lft.sum+cur.best_lazy);
lft.sum=lft.sum+cur.lazy;
rgt.best_lazy=max(rgt.best_lazy,rgt.lazy+cur.best_lazy);
rgt.lazy+=cur.lazy;
rgt.ans=max(rgt.ans,rgt.sum+cur.best_lazy);
rgt.sum+=cur.lazy;
cur.lazy=cur.best_lazy=0;
// }
}
void push_up(data1 &cur, data1 &lft, data1 &rgt)
{
cur.ans=max(lft.ans,rgt.ans);
cur.sum=max(lft.sum,rgt.sum);
}
void update(int n, int b, int e, int i, int j, ll val)
{
if(b>j || e<i) return;
if(b>=i && e<=j)
{
tree[n].best_lazy=max(tree[n].best_lazy,tree[n].lazy+val);
tree[n].lazy+=val;
tree[n].ans=max(tree[n].ans,tree[n].sum+val);
tree[n].sum+=val;
return;
}
segment_tree;
push_down(tree[n],tree[l],tree[r]);
update(l,b,mid,i,j,val);
update(r,mid+1,e,i,j,val);
push_up(tree[n],tree[l],tree[r]);
}
data1 query(int n, int b, int e, int i, int j)
{
if(b>j || e<i) return data1();
if(b>=i && e<=j)
{
return tree[n];
}
segment_tree;
push_down(tree[n],tree[l],tree[r]);
data1 p=query(l,b,mid,i,j);
data1 q=query(r,mid+1,e,i,j);
data1 ret;
push_up(ret,p,q);
return ret;
}
int main()
{
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
int n;
sf(n);
for(int i=1; i<=n; i++) sf(ara[i]);
int m;
sf(m);
data a;
for(int i=0; i<m; i++)
{
sff(a.l,a.r);
a.id=i;
queries.pb(a);
}
sort(all(queries),[](data a,data b)
{
return a.r<b.r;
});
int idx=0;
for(int i=1; i<=n && idx<SZ(queries); i++)
{
// if(last[mx+ara[i]]!=0)
// {
// update(1,1,n,last[mx+ara[i]],0);
// }
int xx=last[mx+ara[i]]+1;
update(1,1,n,xx,i,ara[i]);
last[mx+ara[i]]=i;
while(idx<SZ(queries) && queries[idx].r==i)
{
ans[queries[idx].id]=query(1,1,n,queries[idx].l,queries[idx].r).ans;
idx++;
}
}
for(int i=0; i<m; i++)
printf("%lld\n",ans[i]);
return 0;
}
| [
"tanmoytapos01@gmail.com"
] | tanmoytapos01@gmail.com |
de30974f811bcb0251d4cc1d1492af73ef95db8d | 99e494d9ca83ebafdbe6fbebc554ab229edcbacc | /.history/Day 2/Practice/Answers/StarStrings_20210305184804.cpp | 14c66b82d20427b29f2a17a2dbdc03c29202c3a2 | [] | no_license | Datta2901/CCC | c0364caa1e4937bc7bce68e4847c8d599aef0f59 | 4debb2c1c70df693d0e5f68b5798bd9c7a7ef3dc | refs/heads/master | 2023-04-19T10:05:12.372578 | 2021-04-23T12:50:08 | 2021-04-23T12:50:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 582 | cpp | #include<bits/stdc++.h>
using namespace std;
bool isVowel(char a){
if(a == 'a' || a == 'e' || a == 'i' || a == 'o' || a == 'u'|| a == 'y'){
return true;
}
return false;
}
int main(){
string name;
cin >> name;
bool answer = true;
for(int i = 0; i < name.size() - 1; i++){
if(name[i] == name[i + 1]){
answer = false;
break;
}if(isVowel(name[i]) == isVowel(name[i + 1])){
answer = false;
break;
}
}
if(answer){
cout << "Yes" << endl;
}else
return 0;
} | [
"manikanta2901@gmail.com"
] | manikanta2901@gmail.com |
b97722b346a7e9cda2026089daf1ac734e8c9347 | 7f69e98afe43db75c3d33f7e99dbba702a37a0a7 | /src/plugins/thirdParty/LLVM/lib/Target/X86/X86GenFastISel.inc | c59e14e267db80edb4309a7bdc3751b0ef7cde06 | [
"Apache-2.0"
] | permissive | hsorby/opencor | ce1125ba6a6cd86a811d13d4b54fb12a53a3cc7c | 4ce3332fed67069bd093a6215aeaf81be81c9933 | refs/heads/master | 2021-01-19T07:23:07.743445 | 2015-11-08T13:17:29 | 2015-11-08T13:17:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 588,925 | inc | /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|* *|
|* "Fast" Instruction Selector for the X86 target *|
|* *|
|* Automatically generated file, do not edit! *|
|* *|
\*===----------------------------------------------------------------------===*/
// FastEmit Immediate Predicate functions.
static bool Predicate_i16immSExt8(int64_t Imm) {
return Imm == (int8_t)Imm;
}
static bool Predicate_i32immSExt8(int64_t Imm) {
return Imm == (int8_t)Imm;
}
static bool Predicate_i64immSExt8(int64_t Imm) {
return Imm == (int8_t)Imm;
}
static bool Predicate_i64immSExt32(int64_t Imm) {
return Imm == (int32_t)Imm;
}
static bool Predicate_i8immZExt5(int64_t Imm) {
return Imm >= 0 && Imm < 32;
}
static bool Predicate_i8immZExt3(int64_t Imm) {
return Imm >= 0 && Imm < 8;
}
static bool Predicate_FROUND_NO_EXC(int64_t Imm) {
return Imm == 8;
}
static bool Predicate_FROUND_CURRENT(int64_t Imm) {
return Imm == X86::STATIC_ROUNDING::CUR_DIRECTION;
}
// FastEmit functions for ISD::ANY_EXTEND.
unsigned fastEmit_ISD_ANY_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_r(X86::MOVZX32rr8, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_ANY_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ANY_EXTEND_MVT_i8_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::BITCAST.
unsigned fastEmit_ISD_BITCAST_MVT_i32_MVT_f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVDI2SSZrr, &X86::FR32XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVDI2SSrr, &X86::FR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVDI2SSrr, &X86::FR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_i32_MVT_v32i1_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::KMOVDkr, &X86::VK32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_BITCAST_MVT_i32_MVT_f32_r(Op0, Op0IsKill);
case MVT::v32i1: return fastEmit_ISD_BITCAST_MVT_i32_MVT_v32i1_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_BITCAST_MVT_i64_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOV64toSDZrr, &X86::FR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOV64toSDrr, &X86::FR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOV64toSDrr, &X86::FR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_i64_MVT_v64i1_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::KMOVQkr, &X86::VK64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_i64_MVT_x86mmx_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::MMX_MOVD64to64rr, &X86::VR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasMMX())) {
return fastEmitInst_r(X86::MMX_MOVD64to64rr, &X86::VR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f64: return fastEmit_ISD_BITCAST_MVT_i64_MVT_f64_r(Op0, Op0IsKill);
case MVT::v64i1: return fastEmit_ISD_BITCAST_MVT_i64_MVT_v64i1_r(Op0, Op0IsKill);
case MVT::x86mmx: return fastEmit_ISD_BITCAST_MVT_i64_MVT_x86mmx_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_BITCAST_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVSS2DIZrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVSS2DIrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVSS2DIrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_f64_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVSDto64Zrr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVSDto64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVSDto64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_f64_MVT_x86mmx_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::MMX_MOVFR642Qrr, &X86::VR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_BITCAST_MVT_f64_MVT_i64_r(Op0, Op0IsKill);
case MVT::x86mmx: return fastEmit_ISD_BITCAST_MVT_f64_MVT_x86mmx_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_BITCAST_MVT_v32i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::KMOVDrk, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_v64i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::KMOVQrk, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_x86mmx_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::MMX_MOVD64from64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasMMX())) {
return fastEmitInst_r(X86::MMX_MOVD64from64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_x86mmx_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::MMX_MOVQ2FR64rr, &X86::FR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BITCAST_MVT_x86mmx_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_BITCAST_MVT_x86mmx_MVT_i64_r(Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_BITCAST_MVT_x86mmx_MVT_f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_BITCAST_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_BITCAST_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_BITCAST_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::f32: return fastEmit_ISD_BITCAST_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_BITCAST_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::v32i1: return fastEmit_ISD_BITCAST_MVT_v32i1_r(RetVT, Op0, Op0IsKill);
case MVT::v64i1: return fastEmit_ISD_BITCAST_MVT_v64i1_r(RetVT, Op0, Op0IsKill);
case MVT::x86mmx: return fastEmit_ISD_BITCAST_MVT_x86mmx_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::BRIND.
unsigned fastEmit_ISD_BRIND_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return fastEmitInst_r(X86::JMP16r, &X86::GR16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BRIND_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return fastEmitInst_r(X86::JMP32r, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BRIND_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((Subtarget->is64Bit())) {
return fastEmitInst_r(X86::JMP64r, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_BRIND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_BRIND_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_BRIND_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_BRIND_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::BSWAP.
unsigned fastEmit_ISD_BSWAP_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_r(X86::BSWAP32r, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_BSWAP_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_r(X86::BSWAP64r, &X86::GR64RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_BSWAP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_BSWAP_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_BSWAP_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTLZ.
unsigned fastEmit_ISD_CTLZ_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
if ((Subtarget->hasLZCNT())) {
return fastEmitInst_r(X86::LZCNT16rr, &X86::GR16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTLZ_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasLZCNT())) {
return fastEmitInst_r(X86::LZCNT32rr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTLZ_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasLZCNT())) {
return fastEmitInst_r(X86::LZCNT64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTLZ_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
return fastEmitInst_r(X86::VPLZCNTDrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_CTLZ_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
return fastEmitInst_r(X86::VPLZCNTQrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_CTLZ_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_CTLZ_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_CTLZ_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_CTLZ_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_ISD_CTLZ_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_CTLZ_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTPOP.
unsigned fastEmit_ISD_CTPOP_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
if ((Subtarget->hasPOPCNT())) {
return fastEmitInst_r(X86::POPCNT16rr, &X86::GR16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTPOP_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasPOPCNT())) {
return fastEmitInst_r(X86::POPCNT32rr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTPOP_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasPOPCNT())) {
return fastEmitInst_r(X86::POPCNT64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTPOP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_CTPOP_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_CTPOP_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_CTPOP_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTTZ.
unsigned fastEmit_ISD_CTTZ_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
if ((Subtarget->hasBMI())) {
return fastEmitInst_r(X86::TZCNT16rr, &X86::GR16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTTZ_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasBMI())) {
return fastEmitInst_r(X86::TZCNT32rr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTTZ_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasBMI())) {
return fastEmitInst_r(X86::TZCNT64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_CTTZ_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_CTTZ_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_CTTZ_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_CTTZ_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTTZ_ZERO_UNDEF.
unsigned fastEmit_ISD_CTTZ_ZERO_UNDEF_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_r(X86::BSF16rr, &X86::GR16RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_CTTZ_ZERO_UNDEF_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_r(X86::BSF32rr, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_CTTZ_ZERO_UNDEF_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_r(X86::BSF64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_CTTZ_ZERO_UNDEF_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_CTTZ_ZERO_UNDEF_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_CTTZ_ZERO_UNDEF_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_CTTZ_ZERO_UNDEF_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FABS.
unsigned fastEmit_ISD_FABS_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_r(X86::ABS_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FABS_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::ABS_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FABS_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_r(X86::ABS_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_FABS_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FABS_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FABS_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return fastEmit_ISD_FABS_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FCOS.
unsigned fastEmit_ISD_FCOS_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_r(X86::COS_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FCOS_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::COS_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FCOS_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_r(X86::COS_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_FCOS_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FCOS_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FCOS_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return fastEmit_ISD_FCOS_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FNEG.
unsigned fastEmit_ISD_FNEG_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_r(X86::CHS_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FNEG_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::CHS_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FNEG_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_r(X86::CHS_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_FNEG_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FNEG_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FNEG_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return fastEmit_ISD_FNEG_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_EXTEND.
unsigned fastEmit_ISD_FP_EXTEND_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTSS2SDrr, &X86::FR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_EXTEND_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTPS2PDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2PDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_EXTEND_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTPS2PDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FP_EXTEND_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_ISD_FP_EXTEND_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_ISD_FP_EXTEND_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_ROUND.
unsigned fastEmit_ISD_FP_ROUND_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTSD2SSrr, &X86::FR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_ROUND_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTPD2PSYrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2PSZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_ROUND_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTPD2PSZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_ROUND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f64: return fastEmit_ISD_FP_ROUND_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_FP_ROUND_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_FP_ROUND_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_TO_SINT.
unsigned fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSS2SIZrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTTSS2SIrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSS2SIrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSS2SI64Zrr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTTSS2SI64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSS2SI64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSD2SIZrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTTSD2SIrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSD2SIrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSD2SI64Zrr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTTSD2SI64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSD2SI64rr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTTPS2DQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTTPS2DQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2DQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f32_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2QQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f32_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2QQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_FP_TO_SINT_MVT_v4f32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_FP_TO_SINT_MVT_v4f32_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_FP_TO_SINT_MVT_v4f32_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v8f32_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTTPS2DQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2DQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v8f32_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTTPS2QQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_ISD_FP_TO_SINT_MVT_v8f32_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_FP_TO_SINT_MVT_v8f32_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTPS2DQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v2f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2DQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v2f64_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2QQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_FP_TO_SINT_MVT_v2f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_FP_TO_SINT_MVT_v2f64_MVT_v2i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTTPD2DQYrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2DQZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f64_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2QQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_FP_TO_SINT_MVT_v4f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_FP_TO_SINT_MVT_v4f64_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v8f64_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTPD2DQZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v8f64_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTTPD2QQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_SINT_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_ISD_FP_TO_SINT_MVT_v8f64_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_FP_TO_SINT_MVT_v8f64_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_SINT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FP_TO_SINT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FP_TO_SINT_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_ISD_FP_TO_SINT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_ISD_FP_TO_SINT_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_FP_TO_SINT_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_FP_TO_SINT_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_TO_UINT.
unsigned fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSS2USIZrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSS2USI64Zrr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSD2USIZrr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTSD2USI64Zrr, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2UDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f32_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2UQQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f32_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2UQQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_FP_TO_UINT_MVT_v4f32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_FP_TO_UINT_MVT_v4f32_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_FP_TO_UINT_MVT_v4f32_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v8f32_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPS2UDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v8f32_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTTPS2UQQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_ISD_FP_TO_UINT_MVT_v8f32_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_FP_TO_UINT_MVT_v8f32_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTPS2UDQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v2f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2UDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v2f64_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2UQQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_FP_TO_UINT_MVT_v2f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_FP_TO_UINT_MVT_v2f64_MVT_v2i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2UDQZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f64_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTTPD2UQQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_FP_TO_UINT_MVT_v4f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_FP_TO_UINT_MVT_v4f64_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v8f64_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTTPD2UDQZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v8f64_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTTPD2UQQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FP_TO_UINT_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_ISD_FP_TO_UINT_MVT_v8f64_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_FP_TO_UINT_MVT_v8f64_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_FP_TO_UINT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FP_TO_UINT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FP_TO_UINT_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_ISD_FP_TO_UINT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_ISD_FP_TO_UINT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_ISD_FP_TO_UINT_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_ISD_FP_TO_UINT_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_FP_TO_UINT_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_FP_TO_UINT_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FSIN.
unsigned fastEmit_ISD_FSIN_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_r(X86::SIN_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSIN_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::SIN_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSIN_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_r(X86::SIN_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_FSIN_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FSIN_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FSIN_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return fastEmit_ISD_FSIN_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FSQRT.
unsigned fastEmit_ISD_FSQRT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::SQRTSSr, &X86::FR32RegClass, Op0, Op0IsKill);
}
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_r(X86::SQRT_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::SQRTSDr, &X86::FR64RegClass, Op0, Op0IsKill);
}
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::SQRT_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_r(X86::SQRT_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_FSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VSQRTPSZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::SQRTPSr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VSQRTPSr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VSQRTPSZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VSQRTPSYr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VSQRTPSZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VSQRTPDZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::SQRTPDr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VSQRTPDr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VSQRTPDZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VSQRTPDYr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VSQRTPDZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSQRT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FSQRT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_FSQRT_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return fastEmit_ISD_FSQRT_MVT_f80_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_ISD_FSQRT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_ISD_FSQRT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_ISD_FSQRT_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_ISD_FSQRT_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_FSQRT_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_FSQRT_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SCALAR_TO_VECTOR.
unsigned fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVDI2PDIZrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVDI2PDIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVDI2PDIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_x86mmx_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasMMX())) {
return fastEmitInst_r(X86::MMX_MOVD64rr, &X86::VR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::x86mmx: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_x86mmx_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOV64toPQIZrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOV64toPQIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOV64toPQIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SCALAR_TO_VECTOR_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SIGN_EXTEND.
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::MOVSX32rr8, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::MOVSX64rr8, &X86::GR64RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::MOVSX32rr16, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::MOVSX64rr16, &X86::GR64RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SIGN_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->is64Bit())) {
return fastEmitInst_r(X86::MOVSX64rr32, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SIGN_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SIGN_EXTEND_MVT_i8_r(RetVT, Op0, Op0IsKill);
case MVT::i16: return fastEmit_ISD_SIGN_EXTEND_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_SIGN_EXTEND_MVT_i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SINT_TO_FP.
unsigned fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTSI2SSrr, &X86::FR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTSI2SDrr, &X86::FR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTSI2SS64rr, &X86::FR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTSI2SD64rr, &X86::FR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(Op0, Op0IsKill);
case MVT::f64: return fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTDQ2PSrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTDQ2PSrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTDQ2PSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTDQ2PDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTDQ2PDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i32_MVT_v8f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTDQ2PSYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTDQ2PSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i32_MVT_v8f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTDQ2PDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8f32: return fastEmit_ISD_SINT_TO_FP_MVT_v8i32_MVT_v8f32_r(Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_SINT_TO_FP_MVT_v8i32_MVT_v8f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTDQ2PSZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v2i64_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTQQ2PSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v2i64_MVT_v2f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTQQ2PDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_ISD_SINT_TO_FP_MVT_v2i64_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_ISD_SINT_TO_FP_MVT_v2i64_MVT_v2f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v4i64_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTQQ2PSZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v4i64_MVT_v4f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTQQ2PDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_ISD_SINT_TO_FP_MVT_v4i64_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_SINT_TO_FP_MVT_v4i64_MVT_v4f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTQQ2PSZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTQQ2PDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8f32: return fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f32_r(Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_SINT_TO_FP_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_SINT_TO_FP_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_ISD_SINT_TO_FP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_ISD_SINT_TO_FP_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_SINT_TO_FP_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_SINT_TO_FP_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_SINT_TO_FP_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::TRUNCATE.
unsigned fastEmit_ISD_TRUNCATE_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
if ((Subtarget->is64Bit())) {
return fastEmitInst_extractsubreg(RetVT, Op0, Op0IsKill, X86::sub_8bit);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->is64Bit())) {
return fastEmitInst_extractsubreg(MVT::i8, Op0, Op0IsKill, X86::sub_8bit);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_extractsubreg(MVT::i16, Op0, Op0IsKill, X86::sub_16bit);
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(Op0, Op0IsKill);
case MVT::i16: return fastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_extractsubreg(MVT::i8, Op0, Op0IsKill, X86::sub_8bit);
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_extractsubreg(MVT::i16, Op0, Op0IsKill, X86::sub_16bit);
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_extractsubreg(MVT::i32, Op0, Op0IsKill, X86::sub_32bit);
}
unsigned fastEmit_ISD_TRUNCATE_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(Op0, Op0IsKill);
case MVT::i16: return fastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v16i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVB2MZ128rr, &X86::VK16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v32i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVB2MZ256rr, &X86::VK32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v64i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVB2MZrr, &X86::VK64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v8i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVW2MZ128rr, &X86::VK8RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v16i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVW2MZ256rr, &X86::VK16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v32i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVW2MZrr, &X86::VK32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVD2MZ128rr, &X86::VK4RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVD2MZ256rr, &X86::VK8RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VPMOVD2MZrr, &X86::VK16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVQ2MZ128rr, &X86::VK2RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVQ2MZ256rr, &X86::VK4RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VPMOVQ2MZrr, &X86::VK8RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_TRUNCATE_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_TRUNCATE_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_ISD_TRUNCATE_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_ISD_TRUNCATE_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::v16i8: return fastEmit_ISD_TRUNCATE_MVT_v16i8_r(RetVT, Op0, Op0IsKill);
case MVT::v32i8: return fastEmit_ISD_TRUNCATE_MVT_v32i8_r(RetVT, Op0, Op0IsKill);
case MVT::v64i8: return fastEmit_ISD_TRUNCATE_MVT_v64i8_r(RetVT, Op0, Op0IsKill);
case MVT::v8i16: return fastEmit_ISD_TRUNCATE_MVT_v8i16_r(RetVT, Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_ISD_TRUNCATE_MVT_v16i16_r(RetVT, Op0, Op0IsKill);
case MVT::v32i16: return fastEmit_ISD_TRUNCATE_MVT_v32i16_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_ISD_TRUNCATE_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_ISD_TRUNCATE_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_ISD_TRUNCATE_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_TRUNCATE_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_TRUNCATE_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_TRUNCATE_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::UINT_TO_FP.
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v4i32_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUDQ2PSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v4i32_MVT_v4f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUDQ2PDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_ISD_UINT_TO_FP_MVT_v4i32_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_UINT_TO_FP_MVT_v4i32_MVT_v4f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i32_MVT_v8f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUDQ2PSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i32_MVT_v8f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTUDQ2PDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8f32: return fastEmit_ISD_UINT_TO_FP_MVT_v8i32_MVT_v8f32_r(Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_UINT_TO_FP_MVT_v8i32_MVT_v8f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTUDQ2PSZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v2i64_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUQQ2PSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v2i64_MVT_v2f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUQQ2PDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_ISD_UINT_TO_FP_MVT_v2i64_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_ISD_UINT_TO_FP_MVT_v2i64_MVT_v2f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v4i64_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUQQ2PSZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v4i64_MVT_v4f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUQQ2PDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_ISD_UINT_TO_FP_MVT_v4i64_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_ISD_UINT_TO_FP_MVT_v4i64_MVT_v4f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTUQQ2PSZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTUQQ2PDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8f32: return fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f32_r(Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_ISD_UINT_TO_FP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_UINT_TO_FP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_ISD_UINT_TO_FP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_ISD_UINT_TO_FP_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_ISD_UINT_TO_FP_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_ISD_UINT_TO_FP_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_ISD_UINT_TO_FP_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ZERO_EXTEND.
unsigned fastEmit_ISD_ZERO_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_r(X86::MOVZX32rr8, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_ZERO_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_r(X86::MOVZX32rr16, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_ZERO_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ZERO_EXTEND_MVT_i8_r(RetVT, Op0, Op0IsKill);
case MVT::i16: return fastEmit_ISD_ZERO_EXTEND_MVT_i16_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::ABS.
unsigned fastEmit_X86ISD_ABS_MVT_v16i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v32i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v64i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPABSBZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v8i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v16i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v32i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPABSWZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPABSDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPABSQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPABSQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ABS_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_ABS_MVT_v16i8_r(RetVT, Op0, Op0IsKill);
case MVT::v32i8: return fastEmit_X86ISD_ABS_MVT_v32i8_r(RetVT, Op0, Op0IsKill);
case MVT::v64i8: return fastEmit_X86ISD_ABS_MVT_v64i8_r(RetVT, Op0, Op0IsKill);
case MVT::v8i16: return fastEmit_X86ISD_ABS_MVT_v8i16_r(RetVT, Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_ABS_MVT_v16i16_r(RetVT, Op0, Op0IsKill);
case MVT::v32i16: return fastEmit_X86ISD_ABS_MVT_v32i16_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_X86ISD_ABS_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_ABS_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_ABS_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_ABS_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_ABS_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_ABS_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CALL.
unsigned fastEmit_X86ISD_CALL_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return fastEmitInst_r(X86::CALL16r, &X86::GR16RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CALL_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return fastEmitInst_r(X86::CALL32r, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CALL_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((Subtarget->is64Bit())) {
return fastEmitInst_r(X86::CALL64r, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CALL_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_X86ISD_CALL_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return fastEmit_X86ISD_CALL_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_X86ISD_CALL_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::COMPRESS.
unsigned fastEmit_X86ISD_COMPRESS_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPCOMPRESSDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPCOMPRESSDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPCOMPRESSDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPCOMPRESSQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPCOMPRESSQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPCOMPRESSQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCOMPRESSPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCOMPRESSPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCOMPRESSPSZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCOMPRESSPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCOMPRESSPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCOMPRESSPDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMPRESS_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_COMPRESS_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_COMPRESS_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_COMPRESS_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_COMPRESS_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_COMPRESS_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_COMPRESS_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_COMPRESS_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_COMPRESS_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_COMPRESS_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_COMPRESS_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_COMPRESS_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_COMPRESS_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CVTDQ2PD.
unsigned fastEmit_X86ISD_CVTDQ2PD_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2())) {
return fastEmitInst_r(X86::CVTDQ2PDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTDQ2PDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTDQ2PDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CVTDQ2PD_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_CVTDQ2PD_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CVTUDQ2PD.
unsigned fastEmit_X86ISD_CVTUDQ2PD_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTUDQ2PDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CVTUDQ2PD_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_CVTUDQ2PD_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::EH_RETURN.
unsigned fastEmit_X86ISD_EH_RETURN_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
return fastEmitInst_r(X86::EH_RETURN, &X86::GR32RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_EH_RETURN_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
return fastEmitInst_r(X86::EH_RETURN64, &X86::GR64RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_EH_RETURN_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_EH_RETURN_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_X86ISD_EH_RETURN_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::EXPAND.
unsigned fastEmit_X86ISD_EXPAND_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPEXPANDDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPEXPANDDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPEXPANDDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPEXPANDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPEXPANDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPEXPANDQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VEXPANDPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VEXPANDPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VEXPANDPSZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VEXPANDPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VEXPANDPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VEXPANDPDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_EXPAND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_EXPAND_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_EXPAND_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_EXPAND_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_EXPAND_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_EXPAND_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_EXPAND_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_EXPAND_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_EXPAND_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_EXPAND_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_EXPAND_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_EXPAND_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_EXPAND_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FP_TO_SINT_RND.
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2DQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2QQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2QQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2DQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTPS2QQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTPS2DQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v2f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2DQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v2f64_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2QQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v2f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v2f64_MVT_v2i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2DQZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f64_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2QQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f64_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTPD2DQZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTPD2QQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FP_TO_UINT_RND.
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2UDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2UQQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2UQQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2UDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTPS2UQQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTPS2UDQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v2f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2UDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v2f64_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2UQQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v2f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v2f64_MVT_v2i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f64_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2UDQZ256rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f64_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2UQQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f64_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f64_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VCVTPD2UDQZrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VCVTPD2UQQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FRCP.
unsigned fastEmit_X86ISD_FRCP_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::RCPSSr, &X86::FR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRCP14PSZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::RCPPSr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VRCPPSr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRCP14PSZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VRCPPSYr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VRCP14PSZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRCP14PDZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRCP14PDZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VRCP14PDZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRCP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FRCP_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FRCP_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FRCP_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FRCP_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FRCP_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FRCP_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FRCP_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FRSQRT.
unsigned fastEmit_X86ISD_FRSQRT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::RSQRTSSr, &X86::FR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRSQRT14PSZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::RSQRTPSr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VRSQRTPSr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRSQRT14PSZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VRSQRTPSYr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VRSQRT14PSZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRSQRT14PDZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VRSQRT14PDZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VRSQRT14PDZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FRSQRT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FRSQRT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FRSQRT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FRSQRT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FRSQRT_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FRSQRT_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FRSQRT_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FRSQRT_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MMX_MOVD2W.
unsigned fastEmit_X86ISD_MMX_MOVD2W_MVT_x86mmx_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasMMX())) {
return fastEmitInst_r(X86::MMX_MOVD64grr, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MMX_MOVD2W_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::x86mmx: return fastEmit_X86ISD_MMX_MOVD2W_MVT_x86mmx_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MMX_MOVW2D.
unsigned fastEmit_X86ISD_MMX_MOVW2D_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::x86mmx)
return 0;
if ((Subtarget->hasMMX())) {
return fastEmitInst_r(X86::MMX_MOVD64rr, &X86::VR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MMX_MOVW2D_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_MMX_MOVW2D_MVT_i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVDDUP.
unsigned fastEmit_X86ISD_MOVDDUP_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVDDUPYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVDDUP_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVDDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVDDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVDDUP_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVDDUPYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVDDUP_MVT_v8f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVDDUPZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVDDUP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i64: return fastEmit_X86ISD_MOVDDUP_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_MOVDDUP_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_MOVDDUP_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_MOVDDUP_MVT_v8f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVDQ2Q.
unsigned fastEmit_X86ISD_MOVDQ2Q_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::x86mmx)
return 0;
return fastEmitInst_r(X86::MMX_MOVDQ2Qrr, &X86::VR64RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_MOVDQ2Q_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_MOVDQ2Q_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVSHDUP.
unsigned fastEmit_X86ISD_MOVSHDUP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVSHDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSHDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSHDUP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSHDUPYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSHDUP_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
return fastEmitInst_r(X86::VMOVSHDUPZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_MOVSHDUP_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVSHDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSHDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSHDUP_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSHDUPYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSHDUP_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVSHDUPZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSHDUP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_MOVSHDUP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_MOVSHDUP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_MOVSHDUP_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_MOVSHDUP_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_MOVSHDUP_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_MOVSHDUP_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVSLDUP.
unsigned fastEmit_X86ISD_MOVSLDUP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVSLDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSLDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSLDUP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSLDUPYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSLDUP_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
return fastEmitInst_r(X86::VMOVSLDUPZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_MOVSLDUP_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVSLDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSLDUPrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSLDUP_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VMOVSLDUPYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSLDUP_MVT_v16f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVSLDUPZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVSLDUP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_MOVSLDUP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_MOVSLDUP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_MOVSLDUP_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_MOVSLDUP_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_MOVSLDUP_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_MOVSLDUP_MVT_v16f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::SEG_ALLOCA.
unsigned fastEmit_X86ISD_SEG_ALLOCA_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((!Subtarget->isTarget64BitLP64())) {
return fastEmitInst_r(X86::SEG_ALLOCA_32, &X86::GR32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SEG_ALLOCA_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->is64Bit())) {
return fastEmitInst_r(X86::SEG_ALLOCA_64, &X86::GR64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SEG_ALLOCA_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_SEG_ALLOCA_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_X86ISD_SEG_ALLOCA_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VBROADCAST.
unsigned fastEmit_X86ISD_VBROADCAST_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
return fastEmitInst_r(X86::VPBROADCASTDrZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
return fastEmitInst_r(X86::VPBROADCASTQrZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v16i8_MVT_v16i8_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTBrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v16i8_MVT_v32i8_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTBYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v16i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_VBROADCAST_MVT_v16i8_MVT_v16i8_r(Op0, Op0IsKill);
case MVT::v32i8: return fastEmit_X86ISD_VBROADCAST_MVT_v16i8_MVT_v32i8_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v8i16_MVT_v8i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTWrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v8i16_MVT_v16i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTWYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v8i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VBROADCAST_MVT_v8i16_MVT_v8i16_r(Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VBROADCAST_MVT_v8i16_MVT_v16i16_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4i32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4i32_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4i32_MVT_v16i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPBROADCASTDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_VBROADCAST_MVT_v4i32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VBROADCAST_MVT_v4i32_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_VBROADCAST_MVT_v4i32_MVT_v16i32_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2i64_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2i64_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2i64_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPBROADCASTQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_VBROADCAST_MVT_v2i64_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VBROADCAST_MVT_v2i64_MVT_v4i64_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VBROADCAST_MVT_v2i64_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4f32_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VBROADCASTSSrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VBROADCASTSSZ128r, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4f32_MVT_v8f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VBROADCASTSSYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VBROADCASTSSZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4f32_MVT_v16f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VBROADCASTSSZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_VBROADCAST_MVT_v4f32_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v8f32: return fastEmit_X86ISD_VBROADCAST_MVT_v4f32_MVT_v8f32_r(Op0, Op0IsKill);
case MVT::v16f32: return fastEmit_X86ISD_VBROADCAST_MVT_v4f32_MVT_v16f32_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2f64_MVT_v2f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VPBROADCASTQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2f64_MVT_v4f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2())) {
return fastEmitInst_r(X86::VBROADCASTSDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VBROADCASTSDZ256r, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2f64_MVT_v8f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VBROADCASTSDZr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VBROADCAST_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v2f64: return fastEmit_X86ISD_VBROADCAST_MVT_v2f64_MVT_v2f64_r(Op0, Op0IsKill);
case MVT::v4f64: return fastEmit_X86ISD_VBROADCAST_MVT_v2f64_MVT_v4f64_r(Op0, Op0IsKill);
case MVT::v8f64: return fastEmit_X86ISD_VBROADCAST_MVT_v2f64_MVT_v8f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VBROADCAST_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_VBROADCAST_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return fastEmit_X86ISD_VBROADCAST_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::v16i8: return fastEmit_X86ISD_VBROADCAST_MVT_v16i8_r(RetVT, Op0, Op0IsKill);
case MVT::v8i16: return fastEmit_X86ISD_VBROADCAST_MVT_v8i16_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VBROADCAST_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VBROADCAST_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return fastEmit_X86ISD_VBROADCAST_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_VBROADCAST_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VFPEXT.
unsigned fastEmit_X86ISD_VFPEXT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTPS2PDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTPS2PDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPS2PDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VFPEXT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_VFPEXT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VFPROUND.
unsigned fastEmit_X86ISD_VFPROUND_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::CVTPD2PSrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_r(X86::VCVTPD2PSrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VCVTPD2PSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VFPROUND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v2f64: return fastEmit_X86ISD_VFPROUND_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSEXT.
unsigned fastEmit_X86ISD_VSEXT_MVT_v2i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2QZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v4i1_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2DZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v4i1_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2QZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v4i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_VSEXT_MVT_v4i1_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VSEXT_MVT_v4i1_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i1_MVT_v8i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2WZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i1_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2DZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i1_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VPMOVM2QZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VSEXT_MVT_v8i1_MVT_v8i16_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VSEXT_MVT_v8i1_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VSEXT_MVT_v8i1_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i1_MVT_v16i8_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2BZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i1_MVT_v16i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2WZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i1_MVT_v16i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_r(X86::VPMOVM2DZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_VSEXT_MVT_v16i1_MVT_v16i8_r(Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VSEXT_MVT_v16i1_MVT_v16i16_r(Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_VSEXT_MVT_v16i1_MVT_v16i32_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v32i1_MVT_v32i8_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVM2BZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v32i1_MVT_v32i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVM2WZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v32i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v32i8: return fastEmit_X86ISD_VSEXT_MVT_v32i1_MVT_v32i8_r(Op0, Op0IsKill);
case MVT::v32i16: return fastEmit_X86ISD_VSEXT_MVT_v32i1_MVT_v32i16_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v64i1_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVM2BZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v8i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVSXBWrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXBWrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVSXBWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v16i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXBWYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVSXBWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVSXBDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXBDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXBDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXBDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXBDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v16i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXBDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVSXBQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXBQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXBQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXBQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXBQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXBQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v8i16_r(Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v16i16_r(Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v16i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v4i64_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VSEXT_MVT_v16i8_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v32i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVSXBWZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVSXWDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXWDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXWDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXWDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXWDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVSXWQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXWQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXWQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXWQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXWQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXWQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v4i64_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VSEXT_MVT_v8i16_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v16i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXWDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v4i32_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVSXDQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXDQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v4i32_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVSXDQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_VSEXT_MVT_v4i32_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VSEXT_MVT_v4i32_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VSEXT_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVSXDQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSEXT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i1: return fastEmit_X86ISD_VSEXT_MVT_v2i1_r(RetVT, Op0, Op0IsKill);
case MVT::v4i1: return fastEmit_X86ISD_VSEXT_MVT_v4i1_r(RetVT, Op0, Op0IsKill);
case MVT::v8i1: return fastEmit_X86ISD_VSEXT_MVT_v8i1_r(RetVT, Op0, Op0IsKill);
case MVT::v16i1: return fastEmit_X86ISD_VSEXT_MVT_v16i1_r(RetVT, Op0, Op0IsKill);
case MVT::v32i1: return fastEmit_X86ISD_VSEXT_MVT_v32i1_r(RetVT, Op0, Op0IsKill);
case MVT::v64i1: return fastEmit_X86ISD_VSEXT_MVT_v64i1_r(RetVT, Op0, Op0IsKill);
case MVT::v16i8: return fastEmit_X86ISD_VSEXT_MVT_v16i8_r(RetVT, Op0, Op0IsKill);
case MVT::v32i8: return fastEmit_X86ISD_VSEXT_MVT_v32i8_r(RetVT, Op0, Op0IsKill);
case MVT::v8i16: return fastEmit_X86ISD_VSEXT_MVT_v8i16_r(RetVT, Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VSEXT_MVT_v16i16_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VSEXT_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VSEXT_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VTRUNC.
unsigned fastEmit_X86ISD_VTRUNC_MVT_v16i32_MVT_v16i8_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::VPMOVDBrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VTRUNC_MVT_v16i32_MVT_v16i16_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::VPMOVDWrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VTRUNC_MVT_v16i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_VTRUNC_MVT_v16i32_MVT_v16i8_r(Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VTRUNC_MVT_v16i32_MVT_v16i16_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VTRUNC_MVT_v8i64_MVT_v16i8_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::VPMOVQBrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VTRUNC_MVT_v8i64_MVT_v8i16_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::VPMOVQWrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VTRUNC_MVT_v8i64_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
return fastEmitInst_r(X86::VPMOVQDrr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
unsigned fastEmit_X86ISD_VTRUNC_MVT_v8i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_VTRUNC_MVT_v8i64_MVT_v16i8_r(Op0, Op0IsKill);
case MVT::v8i16: return fastEmit_X86ISD_VTRUNC_MVT_v8i64_MVT_v8i16_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VTRUNC_MVT_v8i64_MVT_v8i32_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VTRUNC_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i32: return fastEmit_X86ISD_VTRUNC_MVT_v16i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VTRUNC_MVT_v8i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VZEXT.
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v8i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVZXBWrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXBWrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVZXBWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v16i16_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXBWYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVZXBWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVZXBDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXBDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXBDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXBDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXBDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v16i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXBDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVZXBQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXBQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXBQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXBQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXBQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXBQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v8i16_r(Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v16i16_r(Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v16i32: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v16i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v4i64_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VZEXT_MVT_v16i8_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v32i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_r(X86::VPMOVZXBWZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVZXWDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXWDrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXWDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v8i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXWDYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXWDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVZXWQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXWQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXWQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXWQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXWQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v8i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXWQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v8i32_r(Op0, Op0IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v4i64_r(Op0, Op0IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VZEXT_MVT_v8i16_MVT_v8i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v16i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXWDZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v4i32_MVT_v2i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::PMOVZXDQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXDQrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v4i32_MVT_v4i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_r(X86::VPMOVZXDQYrr, &X86::VR256RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasVLX()) && (Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_VZEXT_MVT_v4i32_MVT_v2i64_r(Op0, Op0IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VZEXT_MVT_v4i32_MVT_v4i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned fastEmit_X86ISD_VZEXT_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VPMOVZXDQZrr, &X86::VR512RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_VZEXT_MVT_v16i8_r(RetVT, Op0, Op0IsKill);
case MVT::v32i8: return fastEmit_X86ISD_VZEXT_MVT_v32i8_r(RetVT, Op0, Op0IsKill);
case MVT::v8i16: return fastEmit_X86ISD_VZEXT_MVT_v8i16_r(RetVT, Op0, Op0IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VZEXT_MVT_v16i16_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VZEXT_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VZEXT_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VZEXT_MOVL.
unsigned fastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVZPQILo2PQIZrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVZPQILo2PQIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVZPQILo2PQIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVZPQILo2PQIZrr, &X86::VR128XRegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_r(X86::MOVZPQILo2PQIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_r(X86::VMOVZPQILo2PQIrr, &X86::VR128RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VZEXT_MOVL_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return fastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::WIN_FTOL.
unsigned fastEmit_X86ISD_WIN_FTOL_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return fastEmitInst_r(X86::WIN_FTOL_32, &X86::RFP32RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_WIN_FTOL_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return fastEmitInst_r(X86::WIN_FTOL_64, &X86::RFP64RegClass, Op0, Op0IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_WIN_FTOL_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_WIN_FTOL_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return fastEmit_X86ISD_WIN_FTOL_MVT_f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_r(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill) override {
switch (Opcode) {
case ISD::ANY_EXTEND: return fastEmit_ISD_ANY_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::BITCAST: return fastEmit_ISD_BITCAST_r(VT, RetVT, Op0, Op0IsKill);
case ISD::BRIND: return fastEmit_ISD_BRIND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::BSWAP: return fastEmit_ISD_BSWAP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTLZ: return fastEmit_ISD_CTLZ_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTPOP: return fastEmit_ISD_CTPOP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTTZ: return fastEmit_ISD_CTTZ_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTTZ_ZERO_UNDEF: return fastEmit_ISD_CTTZ_ZERO_UNDEF_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FABS: return fastEmit_ISD_FABS_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FCOS: return fastEmit_ISD_FCOS_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FNEG: return fastEmit_ISD_FNEG_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_EXTEND: return fastEmit_ISD_FP_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_ROUND: return fastEmit_ISD_FP_ROUND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_TO_SINT: return fastEmit_ISD_FP_TO_SINT_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_TO_UINT: return fastEmit_ISD_FP_TO_UINT_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FSIN: return fastEmit_ISD_FSIN_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FSQRT: return fastEmit_ISD_FSQRT_r(VT, RetVT, Op0, Op0IsKill);
case ISD::SCALAR_TO_VECTOR: return fastEmit_ISD_SCALAR_TO_VECTOR_r(VT, RetVT, Op0, Op0IsKill);
case ISD::SIGN_EXTEND: return fastEmit_ISD_SIGN_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::SINT_TO_FP: return fastEmit_ISD_SINT_TO_FP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::TRUNCATE: return fastEmit_ISD_TRUNCATE_r(VT, RetVT, Op0, Op0IsKill);
case ISD::UINT_TO_FP: return fastEmit_ISD_UINT_TO_FP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::ZERO_EXTEND: return fastEmit_ISD_ZERO_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::ABS: return fastEmit_X86ISD_ABS_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::CALL: return fastEmit_X86ISD_CALL_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::COMPRESS: return fastEmit_X86ISD_COMPRESS_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::CVTDQ2PD: return fastEmit_X86ISD_CVTDQ2PD_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::CVTUDQ2PD: return fastEmit_X86ISD_CVTUDQ2PD_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::EH_RETURN: return fastEmit_X86ISD_EH_RETURN_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::EXPAND: return fastEmit_X86ISD_EXPAND_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::FP_TO_SINT_RND: return fastEmit_X86ISD_FP_TO_SINT_RND_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::FP_TO_UINT_RND: return fastEmit_X86ISD_FP_TO_UINT_RND_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::FRCP: return fastEmit_X86ISD_FRCP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::FRSQRT: return fastEmit_X86ISD_FRSQRT_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MMX_MOVD2W: return fastEmit_X86ISD_MMX_MOVD2W_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MMX_MOVW2D: return fastEmit_X86ISD_MMX_MOVW2D_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVDDUP: return fastEmit_X86ISD_MOVDDUP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVDQ2Q: return fastEmit_X86ISD_MOVDQ2Q_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVSHDUP: return fastEmit_X86ISD_MOVSHDUP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVSLDUP: return fastEmit_X86ISD_MOVSLDUP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::SEG_ALLOCA: return fastEmit_X86ISD_SEG_ALLOCA_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VBROADCAST: return fastEmit_X86ISD_VBROADCAST_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VFPEXT: return fastEmit_X86ISD_VFPEXT_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VFPROUND: return fastEmit_X86ISD_VFPROUND_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VSEXT: return fastEmit_X86ISD_VSEXT_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VTRUNC: return fastEmit_X86ISD_VTRUNC_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VZEXT: return fastEmit_X86ISD_VZEXT_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VZEXT_MOVL: return fastEmit_X86ISD_VZEXT_MOVL_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::WIN_FTOL: return fastEmit_X86ISD_WIN_FTOL_r(VT, RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned fastEmit_ISD_ADD_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_rr(X86::ADD8rr, &X86::GR8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_ADD_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rr(X86::ADD16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_ADD_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::ADD32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_ADD_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rr(X86::ADD64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_ADD_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PADDBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPADDBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PADDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPADDWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PADDDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPADDDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PADDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPADDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ADD_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_ISD_ADD_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_ISD_ADD_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_ISD_ADD_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i8: return fastEmit_ISD_ADD_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_ISD_ADD_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_ISD_ADD_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_ADD_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_ADD_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_ADD_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_ADD_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_ADD_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_ADD_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_ADD_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_ADD_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_ADD_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned fastEmit_ISD_AND_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_rr(X86::AND8rr, &X86::GR8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_AND_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rr(X86::AND16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_AND_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::AND32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_AND_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rr(X86::AND64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_AND_MVT_v8i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::KANDBrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v16i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::KANDWrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v32i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KANDDrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v64i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KANDQrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPANDDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ANDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PANDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VANDPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPANDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_AND_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_AND_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_ISD_AND_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_ISD_AND_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_ISD_AND_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i1: return fastEmit_ISD_AND_MVT_v8i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i1: return fastEmit_ISD_AND_MVT_v16i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i1: return fastEmit_ISD_AND_MVT_v32i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i1: return fastEmit_ISD_AND_MVT_v64i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_AND_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_AND_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_AND_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_AND_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_AND_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_AND_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FADD.
unsigned fastEmit_ISD_FADD_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VADDSSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ADDSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VADDSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_rr(X86::ADD_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VADDSDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ADDSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VADDSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_rr(X86::ADD_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_rr(X86::ADD_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_FADD_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ADDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VADDPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ADDPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VADDPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VADDPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FADD_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_ISD_FADD_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return fastEmit_ISD_FADD_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_ISD_FADD_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_ISD_FADD_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_ISD_FADD_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_ISD_FADD_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_ISD_FADD_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_ISD_FADD_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FDIV.
unsigned fastEmit_ISD_FDIV_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VDIVSSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::DIVSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VDIVSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_rr(X86::DIV_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VDIVSDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::DIVSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VDIVSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_rr(X86::DIV_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_rr(X86::DIV_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_FDIV_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::DIVPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VDIVPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::DIVPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VDIVPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VDIVPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FDIV_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FDIV_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_ISD_FDIV_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return fastEmit_ISD_FDIV_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_ISD_FDIV_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_ISD_FDIV_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_ISD_FDIV_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_ISD_FDIV_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_ISD_FDIV_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_ISD_FDIV_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FMUL.
unsigned fastEmit_ISD_FMUL_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMULSSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MULSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMULSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_rr(X86::MUL_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMULSDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MULSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMULSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_rr(X86::MUL_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_rr(X86::MUL_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_FMUL_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MULPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMULPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MULPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMULPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMULPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FMUL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FMUL_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_ISD_FMUL_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return fastEmit_ISD_FMUL_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_ISD_FMUL_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_ISD_FMUL_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_ISD_FMUL_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_ISD_FMUL_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_ISD_FMUL_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_ISD_FMUL_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FSUB.
unsigned fastEmit_ISD_FSUB_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VSUBSSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::SUBSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VSUBSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_rr(X86::SUB_Fp32, &X86::RFP32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VSUBSDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::SUBSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VSUBSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_rr(X86::SUB_Fp64, &X86::RFP64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return fastEmitInst_rr(X86::SUB_Fp80, &X86::RFP80RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_FSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::SUBPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VSUBPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::SUBPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VSUBPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VSUBPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_FSUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_ISD_FSUB_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_ISD_FSUB_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return fastEmit_ISD_FSUB_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_ISD_FSUB_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_ISD_FSUB_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_ISD_FSUB_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_ISD_FSUB_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_ISD_FSUB_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_ISD_FSUB_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned fastEmit_ISD_MUL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY), X86::AL).addReg(Op0);
return fastEmitInst_r(X86::MUL8r, &X86::GR8RegClass, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_MUL_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rr(X86::IMUL16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_MUL_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::IMUL32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_MUL_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rr(X86::IMUL64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_MUL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMULLWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMULLWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMULLDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPMULLDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMULLDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasDQI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULLQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VPMULLQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MUL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_MUL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_ISD_MUL_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_ISD_MUL_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_ISD_MUL_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_MUL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_MUL_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_MUL_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_MUL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_MUL_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_MUL_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_MUL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_MUL_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_MUL_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::MULHS.
unsigned fastEmit_ISD_MULHS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMULHWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MULHS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MULHS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMULHWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MULHS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_ISD_MULHS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_MULHS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_MULHS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::MULHU.
unsigned fastEmit_ISD_MULHU_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHUWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMULHUWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHUWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MULHU_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHUWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHUWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MULHU_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMULHUWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_MULHU_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_ISD_MULHU_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_MULHU_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_MULHU_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned fastEmit_ISD_OR_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_rr(X86::OR8rr, &X86::GR8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_OR_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rr(X86::OR16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_OR_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::OR32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_OR_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rr(X86::OR64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_OR_MVT_v8i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::KORBrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v16i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::KORWrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v32i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KORDrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v64i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KORQrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPORDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPORDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPORDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPORQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ORPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PORrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPORrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPORQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VORPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPORYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPORQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_OR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_OR_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_ISD_OR_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_ISD_OR_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_ISD_OR_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i1: return fastEmit_ISD_OR_MVT_v8i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i1: return fastEmit_ISD_OR_MVT_v16i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i1: return fastEmit_ISD_OR_MVT_v32i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i1: return fastEmit_ISD_OR_MVT_v64i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_OR_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_OR_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_OR_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_OR_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_OR_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_OR_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ROTL.
unsigned fastEmit_ISD_ROTL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return fastEmitInst_r(X86::ROL8rCL, &X86::GR8RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_ROTL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPROLVDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPROLVDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPROLVDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPROLVQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPROLVQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPROLVQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ROTL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_ROTL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_ROTL_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_ROTL_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_ROTL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_ROTL_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_ROTL_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ROTR.
unsigned fastEmit_ISD_ROTR_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return fastEmitInst_r(X86::ROR8rCL, &X86::GR8RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_ROTR_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPRORVDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPRORVDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPRORVDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPRORVQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPRORVQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPRORVQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ROTR_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_ROTR_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_ROTR_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_ROTR_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_ROTR_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_ROTR_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_ROTR_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SHL.
unsigned fastEmit_ISD_SHL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return fastEmitInst_r(X86::SHL8rCL, &X86::GR8RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SHL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSLLVWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSLLVWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSLLVWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLVDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSLLVDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLVDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSLLVDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSLLVDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLVQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSLLVQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLVQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSLLVQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSLLVQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SHL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SHL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_SHL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_SHL_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_SHL_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_SHL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_SHL_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_SHL_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_SHL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_SHL_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_SHL_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SMAX.
unsigned fastEmit_ISD_SMAX_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMAXSBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMAXSBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMAXSWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMAXSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMAXSDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMAXSDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXSQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMAXSQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMAX_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_ISD_SMAX_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_ISD_SMAX_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_ISD_SMAX_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_SMAX_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_SMAX_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_SMAX_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_SMAX_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_SMAX_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_SMAX_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_SMAX_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_SMAX_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_SMAX_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SMIN.
unsigned fastEmit_ISD_SMIN_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMINSBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMINSBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMINSWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMINSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMINSDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMINSDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINSQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMINSQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SMIN_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_ISD_SMIN_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_ISD_SMIN_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_ISD_SMIN_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_SMIN_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_SMIN_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_SMIN_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_SMIN_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_SMIN_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_SMIN_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_SMIN_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_SMIN_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_SMIN_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SRA.
unsigned fastEmit_ISD_SRA_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return fastEmitInst_r(X86::SAR8rCL, &X86::GR8RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SRA_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSRAVWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSRAVWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSRAVWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAVDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSRAVDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAVDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSRAVDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSRAVDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAVQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAVQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSRAVQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRA_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SRA_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_SRA_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_SRA_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_SRA_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_SRA_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_SRA_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_SRA_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_SRA_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_SRA_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_SRA_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SRL.
unsigned fastEmit_ISD_SRL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return fastEmitInst_r(X86::SHR8rCL, &X86::GR8RegClass, Op0, Op0IsKill);
}
unsigned fastEmit_ISD_SRL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSRLVWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSRLVWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSRLVWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLVDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSRLVDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLVDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSRLVDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSRLVDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLVQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSRLVQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLVQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSRLVQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSRLVQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SRL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SRL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_SRL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_SRL_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_SRL_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_SRL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_SRL_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_SRL_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_SRL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_SRL_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_SRL_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned fastEmit_ISD_SUB_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_rr(X86::SUB8rr, &X86::GR8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_SUB_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rr(X86::SUB16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_SUB_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::SUB32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_SUB_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rr(X86::SUB64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_SUB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSUBBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSUBBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSUBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSUBWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSUBDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSUBDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSUBQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPSUBQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_SUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SUB_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_ISD_SUB_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_ISD_SUB_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_ISD_SUB_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i8: return fastEmit_ISD_SUB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_ISD_SUB_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_ISD_SUB_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_SUB_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_SUB_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_SUB_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_SUB_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_SUB_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_SUB_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_SUB_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_SUB_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_SUB_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::UMAX.
unsigned fastEmit_ISD_UMAX_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMAXUBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMAXUBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMAXUWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMAXUWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMAXUDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMAXUDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMAXUQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMAXUQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMAX_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_ISD_UMAX_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_ISD_UMAX_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_ISD_UMAX_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_UMAX_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_UMAX_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_UMAX_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_UMAX_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_UMAX_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_UMAX_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_UMAX_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_UMAX_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_UMAX_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::UMIN.
unsigned fastEmit_ISD_UMIN_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMINUBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMINUBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMINUWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMINUWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMINUDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMINUDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMINUQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMINUQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_UMIN_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_ISD_UMIN_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_ISD_UMIN_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_ISD_UMIN_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_ISD_UMIN_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_ISD_UMIN_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_ISD_UMIN_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_UMIN_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_UMIN_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_UMIN_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_UMIN_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_UMIN_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_UMIN_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned fastEmit_ISD_XOR_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_rr(X86::XOR8rr, &X86::GR8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_XOR_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rr(X86::XOR16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_XOR_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::XOR32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_XOR_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rr(X86::XOR64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_ISD_XOR_MVT_v8i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::KXORBrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v16i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::KXORWrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v32i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KXORDrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v64i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KXORQrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPXORDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPXORDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPXORDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPXORQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::XORPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PXORrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPXORrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPXORQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VXORPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPXORYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPXORQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_ISD_XOR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_XOR_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_ISD_XOR_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_ISD_XOR_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_ISD_XOR_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i1: return fastEmit_ISD_XOR_MVT_v8i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i1: return fastEmit_ISD_XOR_MVT_v16i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i1: return fastEmit_ISD_XOR_MVT_v32i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i1: return fastEmit_ISD_XOR_MVT_v64i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_ISD_XOR_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_ISD_XOR_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_ISD_XOR_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_ISD_XOR_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_ISD_XOR_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_ISD_XOR_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::ADDS.
unsigned fastEmit_X86ISD_ADDS_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDS_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDS_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPADDSBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPADDSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_ADDS_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_ADDS_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_ADDS_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_ADDS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_ADDS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_ADDS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::ADDSUB.
unsigned fastEmit_X86ISD_ADDSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ADDSUBPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VADDSUBPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDSUB_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VADDSUBPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ADDSUBPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VADDSUBPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDSUB_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VADDSUBPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDSUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_ADDSUB_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_ADDSUB_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_ADDSUB_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_ADDSUB_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::ADDUS.
unsigned fastEmit_X86ISD_ADDUS_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDUSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDUS_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDUSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDUS_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPADDUSBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDUS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDUSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDUS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPADDUSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDUS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPADDUSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ADDUS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_ADDUS_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_ADDUS_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_ADDUS_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_ADDUS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_ADDUS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_ADDUS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::ANDNP.
unsigned fastEmit_X86ISD_ANDNP_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDNDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ANDNP_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDNDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ANDNP_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPANDNDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ANDNP_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDNQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::ANDNPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PANDNrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDNrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ANDNP_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDNQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VANDNPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPANDNYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ANDNP_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPANDNQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_ANDNP_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_ANDNP_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_ANDNP_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_ANDNP_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_ANDNP_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_ANDNP_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_ANDNP_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::AVG.
unsigned fastEmit_X86ISD_AVG_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPAVGBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_AVG_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPAVGBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_AVG_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPAVGBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_AVG_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPAVGWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_AVG_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPAVGWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_AVG_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPAVGWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_AVG_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_AVG_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_AVG_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_AVG_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_AVG_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_AVG_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_AVG_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::BEXTR.
unsigned fastEmit_X86ISD_BEXTR_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasBMI())) {
return fastEmitInst_rr(X86::BEXTR32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_BEXTR_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasBMI())) {
return fastEmitInst_rr(X86::BEXTR64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_BEXTR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_BEXTR_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_X86ISD_BEXTR_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::BT.
unsigned fastEmit_X86ISD_BT_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::BT16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_BT_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::BT32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_BT_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::BT64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_BT_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_X86ISD_BT_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_X86ISD_BT_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_X86ISD_BT_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned fastEmit_X86ISD_CMP_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::CMP8rr, &X86::GR8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_CMP_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::CMP16rr, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_CMP_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::CMP32rr, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_CMP_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::CMP64rr, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_CMP_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUCOMISSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::UCOMISSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUCOMISSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE1())) {
return fastEmitInst_rr(X86::UCOM_FpIr32, &X86::RFP32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CMP_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUCOMISDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::UCOMISDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUCOMISDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((!Subtarget->hasSSE2())) {
return fastEmitInst_rr(X86::UCOM_FpIr64, &X86::RFP64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_CMP_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rr(X86::UCOM_FpIr80, &X86::RFP80RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned fastEmit_X86ISD_CMP_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_X86ISD_CMP_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return fastEmit_X86ISD_CMP_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return fastEmit_X86ISD_CMP_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return fastEmit_X86ISD_CMP_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f32: return fastEmit_X86ISD_CMP_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_CMP_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return fastEmit_X86ISD_CMP_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::COMI.
unsigned fastEmit_X86ISD_COMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VCOMISSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::Int_COMISSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VCOMISSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VCOMISDZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::Int_COMISDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VCOMISDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_COMI_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_COMI_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_COMI_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FAND.
unsigned fastEmit_X86ISD_FAND_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsANDPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsANDPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsANDPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsANDPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvANDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvANDPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FAND_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FAND_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FAND_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FAND_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FAND_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FAND_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FAND_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FAND_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FAND_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FANDN.
unsigned fastEmit_X86ISD_FANDN_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsANDNPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsANDNPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsANDNPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsANDNPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDNPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvANDNPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDNPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDNPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDNPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDNPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDNPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvANDNPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDNPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDNPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvANDNPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VANDNPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FANDN_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FANDN_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FANDN_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FANDN_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FANDN_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FANDN_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FANDN_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FANDN_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FANDN_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FHADD.
unsigned fastEmit_X86ISD_FHADD_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::HADDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHADDPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHADD_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHADDPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHADD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::HADDPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHADDPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHADD_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHADDPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FHADD_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FHADD_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FHADD_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FHADD_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FHSUB.
unsigned fastEmit_X86ISD_FHSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::HSUBPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHSUBPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHSUB_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHSUBPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::HSUBPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHSUBPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHSUB_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VHSUBPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FHSUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FHSUB_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FHSUB_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FHSUB_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FHSUB_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMAX.
unsigned fastEmit_X86ISD_FMAX_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXSSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXSDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAX_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FMAX_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FMAX_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FMAX_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FMAX_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FMAX_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FMAX_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FMAX_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FMAX_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMAXC.
unsigned fastEmit_X86ISD_FMAXC_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXCSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXCSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAXC_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXCSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMAXCSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAXC_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXCPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXCPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAXC_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXCPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAXC_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MAXCPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXCPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAXC_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMAXCPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMAXC_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FMAXC_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FMAXC_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FMAXC_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FMAXC_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FMAXC_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FMAXC_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMIN.
unsigned fastEmit_X86ISD_FMIN_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINSSZrr, &X86::FR32XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINSDZrr, &X86::FR64XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMIN_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FMIN_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FMIN_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FMIN_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FMIN_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FMIN_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FMIN_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FMIN_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FMIN_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMINC.
unsigned fastEmit_X86ISD_FMINC_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINCSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINCSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMINC_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINCSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMINCSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMINC_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINCPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINCPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMINC_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINCPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMINC_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MINCPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINCPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMINC_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VMINCPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FMINC_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FMINC_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FMINC_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FMINC_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FMINC_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FMINC_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FMINC_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FOR.
unsigned fastEmit_X86ISD_FOR_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsORPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsORPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsORPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsORPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VORPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvORPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvORPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VORPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvORPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VORPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VORPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvORPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvORPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VORPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvORPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VORPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FOR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FOR_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FOR_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FOR_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FOR_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FOR_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FOR_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FOR_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FOR_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FXOR.
unsigned fastEmit_X86ISD_FXOR_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsXORPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsXORPSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FsXORPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VFsXORPDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VXORPSZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvXORPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvXORPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VXORPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvXORPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VXORPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VXORPDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::FvXORPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvXORPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VXORPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VFvXORPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::VXORPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_FXOR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FXOR_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return fastEmit_X86ISD_FXOR_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_FXOR_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_FXOR_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_FXOR_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_FXOR_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_FXOR_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_FXOR_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::HADD.
unsigned fastEmit_X86ISD_HADD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PHADDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPHADDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HADD_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPHADDWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HADD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PHADDDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPHADDDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HADD_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPHADDDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_HADD_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_HADD_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_HADD_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_HADD_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::HSUB.
unsigned fastEmit_X86ISD_HSUB_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PHSUBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPHSUBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HSUB_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPHSUBWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HSUB_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PHSUBDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPHSUBDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HSUB_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPHSUBDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_HSUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_HSUB_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_HSUB_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_HSUB_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_HSUB_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::KORTEST.
unsigned fastEmit_X86ISD_KORTEST_MVT_v8i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_rr(X86::KORTESTBrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_KORTEST_MVT_v16i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::KORTESTWrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_KORTEST_MVT_v32i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KORTESTDrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_KORTEST_MVT_v64i1_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::KORTESTQrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_KORTEST_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i1: return fastEmit_X86ISD_KORTEST_MVT_v8i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i1: return fastEmit_X86ISD_KORTEST_MVT_v16i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i1: return fastEmit_X86ISD_KORTEST_MVT_v32i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i1: return fastEmit_X86ISD_KORTEST_MVT_v64i1_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVHLPS.
unsigned fastEmit_X86ISD_MOVHLPS_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVHLPSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MOVHLPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVHLPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVHLPS_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MOVHLPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVHLPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVHLPSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVHLPS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_MOVHLPS_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_MOVHLPS_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVLHPS.
unsigned fastEmit_X86ISD_MOVLHPS_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVLHPSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MOVLHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVLHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVLHPS_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVLHPSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MOVLHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVLHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVLHPS_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::MOVLHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVLHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VMOVLHPSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MOVLHPS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_MOVLHPS_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_MOVLHPS_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_MOVLHPS_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MULHRS.
unsigned fastEmit_X86ISD_MULHRS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHRSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MULHRS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULHRSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MULHRS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPMULHRSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_MULHRS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_MULHRS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_MULHRS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_MULHRS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PACKSS.
unsigned fastEmit_X86ISD_PACKSS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKSSWBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PACKSSWBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPACKSSWBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKSS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKSSWBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPACKSSWBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKSS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKSSWBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKSS_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKSSDWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PACKSSDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPACKSSDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKSS_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKSSDWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPACKSSDWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKSS_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKSSDWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKSS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_PACKSS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PACKSS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_PACKSS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PACKSS_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PACKSS_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_PACKSS_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PACKUS.
unsigned fastEmit_X86ISD_PACKUS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKUSWBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PACKUSWBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPACKUSWBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKUS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKUSWBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPACKUSWBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKUS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKUSWBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKUS_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKUSDWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41())) {
return fastEmitInst_rr(X86::PACKUSDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPACKUSDWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKUS_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKUSDWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPACKUSDWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKUS_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPACKUSDWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PACKUS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_PACKUS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PACKUS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_PACKUS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PACKUS_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PACKUS_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_PACKUS_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPEQ.
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPEQBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPEQWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPEQDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPEQQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPCMPEQQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PCMPEQ_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_PCMPEQ_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_PCMPEQ_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PCMPEQ_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PCMPEQ_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PCMPEQ_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_PCMPEQ_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_PCMPEQ_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPEQM.
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQBZ128rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQBZ256rr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPCMPEQBZrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQWZ128rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQWZ256rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPCMPEQWZrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQDZ128rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQDZ256rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPCMPEQDZrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQQZ128rr, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPEQQZ256rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPCMPEQQZrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPEQM_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PCMPEQM_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_PCMPEQM_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_PCMPEQM_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_PCMPEQM_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PCMPEQM_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_PCMPEQM_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PCMPEQM_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PCMPEQM_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_PCMPEQM_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_PCMPEQM_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_PCMPEQM_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_PCMPEQM_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPGT.
unsigned fastEmit_X86ISD_PCMPGT_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPGTBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPGTWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPGTDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE42() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PCMPGTQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPCMPGTQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPCMPGTQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGT_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PCMPGT_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_PCMPGT_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_PCMPGT_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PCMPGT_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PCMPGT_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PCMPGT_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_PCMPGT_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_PCMPGT_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPGTM.
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTBZ128rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTBZ256rr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPCMPGTBZrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTWZ128rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTWZ256rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPCMPGTWZrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTDZ128rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTDZ256rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPCMPGTDZrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTQZ128rr, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPCMPGTQZ256rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPCMPGTQZrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PCMPGTM_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PCMPGTM_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_PCMPGTM_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_PCMPGTM_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_PCMPGTM_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PCMPGTM_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_PCMPGTM_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PCMPGTM_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PCMPGTM_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_PCMPGTM_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_PCMPGTM_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_PCMPGTM_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_PCMPGTM_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PMULDQ.
unsigned fastEmit_X86ISD_PMULDQ_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMULDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PMULDQ_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PMULDQ_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMULDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PMULDQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_PMULDQ_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PMULDQ_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_PMULDQ_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PMULUDQ.
unsigned fastEmit_X86ISD_PMULUDQ_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULUDQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PMULUDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPMULUDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PMULUDQ_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPMULUDQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPMULUDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PMULUDQ_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPMULUDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PMULUDQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_PMULUDQ_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PMULUDQ_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_PMULUDQ_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFB.
unsigned fastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSHUFBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSHUFBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPSHUFBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFB_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSHUFBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSHUFBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFB_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSHUFBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_PSHUFB_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_PSHUFB_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSIGN.
unsigned fastEmit_X86ISD_PSIGN_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSIGNBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPSIGNBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSIGN_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSIGNBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSIGN_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSIGNWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPSIGNWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSIGN_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSIGNWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSIGN_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSSE3() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSIGNDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPSIGNDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSIGN_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPSIGNDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PSIGN_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PSIGN_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_PSIGN_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_PSIGN_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_PSIGN_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_PSIGN_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_PSIGN_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PTEST.
unsigned fastEmit_X86ISD_PTEST_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PTESTrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPTESTrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PTEST_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPTESTYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_PTEST_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_PTEST_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_PTEST_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::SUBS.
unsigned fastEmit_X86ISD_SUBS_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBS_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBS_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSUBSBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSUBSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_SUBS_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_SUBS_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_SUBS_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_SUBS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_SUBS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_SUBS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::SUBUS.
unsigned fastEmit_X86ISD_SUBUS_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSBZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSUBUSBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSBrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBUS_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSBZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSBYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBUS_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i8)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSUBUSBZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBUS_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSUBUSWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBUS_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSUBUSWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBUS_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPSUBUSWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_SUBUS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_SUBUS_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_SUBUS_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_SUBUS_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_SUBUS_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_SUBUS_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_SUBUS_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::TESTM.
unsigned fastEmit_X86ISD_TESTM_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTMBZ128rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTMBZ256rr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTMBZrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTMWZ128rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTMWZ256rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTMWZrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTMDZ128rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTMDZ256rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPTESTMDZrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTMQZ128rr, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTMQZ256rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPTESTMQZrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTM_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_TESTM_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_TESTM_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_TESTM_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_TESTM_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_TESTM_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_TESTM_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_TESTM_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_TESTM_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_TESTM_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_TESTM_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_TESTM_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_TESTM_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::TESTNM.
unsigned fastEmit_X86ISD_TESTNM_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTNMBZ128rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTNMBZ256rr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v64i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTNMBZrr, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTNMWZ128rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTNMWZ256rr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPTESTNMWZrr, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTNMDZ128rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTNMDZ256rr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPTESTNMDZrr, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTNMQZ128rr, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPTESTNMQZ256rr, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPTESTNMQZrr, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTNM_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_TESTNM_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_TESTNM_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v64i8: return fastEmit_X86ISD_TESTNM_MVT_v64i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_TESTNM_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_TESTNM_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_TESTNM_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_TESTNM_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_TESTNM_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_TESTNM_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_TESTNM_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_TESTNM_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_TESTNM_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::TESTP.
unsigned fastEmit_X86ISD_TESTP_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VTESTPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTP_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VTESTPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTP_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VTESTPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTP_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VTESTPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_TESTP_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_TESTP_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_TESTP_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_TESTP_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_TESTP_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UCOMI.
unsigned fastEmit_X86ISD_UCOMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VUCOMISSZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::Int_UCOMISSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VUCOMISSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UCOMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VUCOMISDZrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::Int_UCOMISDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::Int_VUCOMISDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UCOMI_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_UCOMI_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_UCOMI_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UNPCKH.
unsigned fastEmit_X86ISD_UNPCKH_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKHBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKHBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKHBWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKHWDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKHWDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKHWDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKHDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKHDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VUNPCKHPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKHDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPUNPCKHDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKHQDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKHQDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VUNPCKHPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKHQDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPUNPCKHQDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::UNPCKHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKHPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKHPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUNPCKHPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::UNPCKHPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKHPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKHPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUNPCKHPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKH_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_UNPCKH_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_UNPCKH_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_UNPCKH_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_UNPCKH_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_UNPCKH_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_UNPCKH_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_UNPCKH_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_UNPCKH_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_UNPCKH_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_UNPCKH_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_UNPCKH_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_UNPCKH_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_UNPCKH_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_UNPCKH_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_UNPCKH_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_UNPCKH_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UNPCKL.
unsigned fastEmit_X86ISD_UNPCKL_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKLBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKLBWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v32i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKLBWYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKLWDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKLWDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKLWDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKLDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKLDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VUNPCKLPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKLDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPUNPCKLDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PUNPCKLQDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VPUNPCKLQDQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VUNPCKLPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPUNPCKLQDQYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPUNPCKLQDQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::UNPCKLPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKLPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKLPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUNPCKLPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::UNPCKLPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKLPDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::VUNPCKLPDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VUNPCKLPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_UNPCKL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_UNPCKL_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i8: return fastEmit_X86ISD_UNPCKL_MVT_v32i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return fastEmit_X86ISD_UNPCKL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_UNPCKL_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_UNPCKL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_UNPCKL_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_UNPCKL_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_UNPCKL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_UNPCKL_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_UNPCKL_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return fastEmit_X86ISD_UNPCKL_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_UNPCKL_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_UNPCKL_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return fastEmit_X86ISD_UNPCKL_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_UNPCKL_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_UNPCKL_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERMV.
unsigned fastEmit_X86ISD_VPERMV_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPERMWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v16i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPERMWZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v32i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rr(X86::VPERMWZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPERMDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPERMDYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v16i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPERMDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPERMQZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v8i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPERMQZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPERMPSZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rr(X86::VPERMPSYrr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v16f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPERMPSZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPERMPDZ256rr, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_MVT_v8f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rr(X86::VPERMPDZrr, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMV_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VPERMV_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i16: return fastEmit_X86ISD_VPERMV_MVT_v16i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v32i16: return fastEmit_X86ISD_VPERMV_MVT_v32i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i32: return fastEmit_X86ISD_VPERMV_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i32: return fastEmit_X86ISD_VPERMV_MVT_v16i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return fastEmit_X86ISD_VPERMV_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i64: return fastEmit_X86ISD_VPERMV_MVT_v8i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return fastEmit_X86ISD_VPERMV_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16f32: return fastEmit_X86ISD_VPERMV_MVT_v16f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return fastEmit_X86ISD_VPERMV_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f64: return fastEmit_X86ISD_VPERMV_MVT_v8f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSHL.
unsigned fastEmit_X86ISD_VSHL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSLLWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSLLDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSLLQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSLLQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VSHL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VSHL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VSHL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSRA.
unsigned fastEmit_X86ISD_VSRA_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSRAWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRA_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRADZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSRADrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRADrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRA_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRAQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRA_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VSRA_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VSRA_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VSRA_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSRL.
unsigned fastEmit_X86ISD_VSRL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLWZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSRLWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLWrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLDZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSRLDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLDrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRL_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLQZ128rr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rr(X86::PSRLQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_rr(X86::VPSRLQrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VSRL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return fastEmit_X86ISD_VSRL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return fastEmit_X86ISD_VSRL_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_rr(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) override {
switch (Opcode) {
case ISD::ADD: return fastEmit_ISD_ADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::AND: return fastEmit_ISD_AND_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FADD: return fastEmit_ISD_FADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FDIV: return fastEmit_ISD_FDIV_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FMUL: return fastEmit_ISD_FMUL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FSUB: return fastEmit_ISD_FSUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::MUL: return fastEmit_ISD_MUL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::MULHS: return fastEmit_ISD_MULHS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::MULHU: return fastEmit_ISD_MULHU_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::OR: return fastEmit_ISD_OR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::ROTL: return fastEmit_ISD_ROTL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::ROTR: return fastEmit_ISD_ROTR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SHL: return fastEmit_ISD_SHL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SMAX: return fastEmit_ISD_SMAX_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SMIN: return fastEmit_ISD_SMIN_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SRA: return fastEmit_ISD_SRA_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SRL: return fastEmit_ISD_SRL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SUB: return fastEmit_ISD_SUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::UMAX: return fastEmit_ISD_UMAX_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::UMIN: return fastEmit_ISD_UMIN_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::XOR: return fastEmit_ISD_XOR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::ADDS: return fastEmit_X86ISD_ADDS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::ADDSUB: return fastEmit_X86ISD_ADDSUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::ADDUS: return fastEmit_X86ISD_ADDUS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::ANDNP: return fastEmit_X86ISD_ANDNP_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::AVG: return fastEmit_X86ISD_AVG_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::BEXTR: return fastEmit_X86ISD_BEXTR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::BT: return fastEmit_X86ISD_BT_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::CMP: return fastEmit_X86ISD_CMP_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::COMI: return fastEmit_X86ISD_COMI_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FAND: return fastEmit_X86ISD_FAND_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FANDN: return fastEmit_X86ISD_FANDN_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FHADD: return fastEmit_X86ISD_FHADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FHSUB: return fastEmit_X86ISD_FHSUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FMAX: return fastEmit_X86ISD_FMAX_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FMAXC: return fastEmit_X86ISD_FMAXC_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FMIN: return fastEmit_X86ISD_FMIN_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FMINC: return fastEmit_X86ISD_FMINC_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FOR: return fastEmit_X86ISD_FOR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FXOR: return fastEmit_X86ISD_FXOR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::HADD: return fastEmit_X86ISD_HADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::HSUB: return fastEmit_X86ISD_HSUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::KORTEST: return fastEmit_X86ISD_KORTEST_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::MOVHLPS: return fastEmit_X86ISD_MOVHLPS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::MOVLHPS: return fastEmit_X86ISD_MOVLHPS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::MULHRS: return fastEmit_X86ISD_MULHRS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PACKSS: return fastEmit_X86ISD_PACKSS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PACKUS: return fastEmit_X86ISD_PACKUS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPEQ: return fastEmit_X86ISD_PCMPEQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPEQM: return fastEmit_X86ISD_PCMPEQM_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPGT: return fastEmit_X86ISD_PCMPGT_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPGTM: return fastEmit_X86ISD_PCMPGTM_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PMULDQ: return fastEmit_X86ISD_PMULDQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PMULUDQ: return fastEmit_X86ISD_PMULUDQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PSHUFB: return fastEmit_X86ISD_PSHUFB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PSIGN: return fastEmit_X86ISD_PSIGN_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PTEST: return fastEmit_X86ISD_PTEST_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::SUBS: return fastEmit_X86ISD_SUBS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::SUBUS: return fastEmit_X86ISD_SUBUS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::TESTM: return fastEmit_X86ISD_TESTM_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::TESTNM: return fastEmit_X86ISD_TESTNM_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::TESTP: return fastEmit_X86ISD_TESTP_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UCOMI: return fastEmit_X86ISD_UCOMI_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UNPCKH: return fastEmit_X86ISD_UNPCKH_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UNPCKL: return fastEmit_X86ISD_UNPCKL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VPERMV: return fastEmit_X86ISD_VPERMV_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VSHL: return fastEmit_X86ISD_VSHL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VSRA: return fastEmit_X86ISD_VSRA_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VSRL: return fastEmit_X86ISD_VSRL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::BLENDI.
unsigned fastEmit_X86ISD_BLENDI_MVT_v8i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::PBLENDWrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VPBLENDWrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v16i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPBLENDWYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v4i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPBLENDDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPBLENDDYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::BLENDPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VBLENDPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VBLENDPSYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::BLENDPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VBLENDPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VBLENDPDYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_BLENDI_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_BLENDI_MVT_v8i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i16: return fastEmit_X86ISD_BLENDI_MVT_v16i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i32: return fastEmit_X86ISD_BLENDI_MVT_v4i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return fastEmit_X86ISD_BLENDI_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f32: return fastEmit_X86ISD_BLENDI_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_BLENDI_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_BLENDI_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_BLENDI_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMPM.
unsigned fastEmit_X86ISD_CMPM_MVT_v16i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPBZ128rri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v32i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPBZ256rri, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v64i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rri(X86::VPCMPBZrri, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v8i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPWZ128rri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v16i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPWZ256rri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v32i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rri(X86::VPCMPWZrri, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v4i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPDZ128rri, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPDZ256rri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v16i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VPCMPDZrri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v2i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPQZ128rri, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPQZ256rri, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v8i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VPCMPQZrri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VCMPPSZ128rri, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VCMPPSZ256rri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VCMPPSZrri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VCMPPDZ128rri, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VCMPPDZ256rri, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VCMPPDZrri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPM_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_CMPM_MVT_v16i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v32i8: return fastEmit_X86ISD_CMPM_MVT_v32i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v64i8: return fastEmit_X86ISD_CMPM_MVT_v64i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i16: return fastEmit_X86ISD_CMPM_MVT_v8i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i16: return fastEmit_X86ISD_CMPM_MVT_v16i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v32i16: return fastEmit_X86ISD_CMPM_MVT_v32i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i32: return fastEmit_X86ISD_CMPM_MVT_v4i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return fastEmit_X86ISD_CMPM_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i32: return fastEmit_X86ISD_CMPM_MVT_v16i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2i64: return fastEmit_X86ISD_CMPM_MVT_v2i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return fastEmit_X86ISD_CMPM_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i64: return fastEmit_X86ISD_CMPM_MVT_v8i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f32: return fastEmit_X86ISD_CMPM_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_CMPM_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_CMPM_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_CMPM_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_CMPM_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_CMPM_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMPMU.
unsigned fastEmit_X86ISD_CMPMU_MVT_v16i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUBZ128rri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v32i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUBZ256rri, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v64i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rri(X86::VPCMPUBZrri, &X86::VK64RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v8i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUWZ128rri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v16i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasBWI()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUWZ256rri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v32i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_rri(X86::VPCMPUWZrri, &X86::VK32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v4i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUDZ128rri, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUDZ256rri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v16i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VPCMPUDZrri, &X86::VK16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v2i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUQZ128rri, &X86::VK2RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i1)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VPCMPUQZ256rri, &X86::VK4RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_MVT_v8i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VPCMPUQZrri, &X86::VK8RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPMU_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_CMPMU_MVT_v16i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v32i8: return fastEmit_X86ISD_CMPMU_MVT_v32i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v64i8: return fastEmit_X86ISD_CMPMU_MVT_v64i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i16: return fastEmit_X86ISD_CMPMU_MVT_v8i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i16: return fastEmit_X86ISD_CMPMU_MVT_v16i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v32i16: return fastEmit_X86ISD_CMPMU_MVT_v32i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i32: return fastEmit_X86ISD_CMPMU_MVT_v4i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return fastEmit_X86ISD_CMPMU_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i32: return fastEmit_X86ISD_CMPMU_MVT_v16i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2i64: return fastEmit_X86ISD_CMPMU_MVT_v2i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return fastEmit_X86ISD_CMPMU_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i64: return fastEmit_X86ISD_CMPMU_MVT_v8i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMPP.
unsigned fastEmit_X86ISD_CMPP_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::CMPPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VCMPPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPP_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VCMPPSYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPP_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::CMPPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VCMPPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPP_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VCMPPDYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_CMPP_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_CMPP_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_CMPP_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_CMPP_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_CMPP_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FADD_RND.
unsigned fastEmit_X86ISD_FADD_RND_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VADDSSZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FADD_RND_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VADDPSZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FADD_RND_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VADDSDZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FADD_RND_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VADDPDZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FADD_RND_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FADD_RND_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_FADD_RND_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_FADD_RND_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_FADD_RND_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FDIV_RND.
unsigned fastEmit_X86ISD_FDIV_RND_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VDIVSSZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FDIV_RND_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VDIVPSZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FDIV_RND_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VDIVSDZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FDIV_RND_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VDIVPDZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FDIV_RND_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FDIV_RND_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_FDIV_RND_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_FDIV_RND_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_FDIV_RND_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMUL_RND.
unsigned fastEmit_X86ISD_FMUL_RND_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VMULSSZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FMUL_RND_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VMULPSZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FMUL_RND_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VMULSDZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FMUL_RND_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VMULPDZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FMUL_RND_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FMUL_RND_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_FMUL_RND_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_FMUL_RND_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_FMUL_RND_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSETCC.
unsigned fastEmit_X86ISD_FSETCC_MVT_f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VCMPSSZrr, &X86::VK1RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSETCC_MVT_f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VCMPSDZrr, &X86::VK1RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSETCC_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FSETCC_MVT_f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::f64: return fastEmit_X86ISD_FSETCC_MVT_f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSUB_RND.
unsigned fastEmit_X86ISD_FSUB_RND_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSUBSSZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSUB_RND_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSUBPSZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSUB_RND_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSUBSDZrrb, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSUB_RND_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSUBPDZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSUB_RND_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_FSUB_RND_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_FSUB_RND_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_FSUB_RND_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_FSUB_RND_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::INSERTPS.
unsigned fastEmit_X86ISD_INSERTPS_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VINSERTPSzrr, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::INSERTPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VINSERTPSrr, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_INSERTPS_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return fastEmit_X86ISD_INSERTPS_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SCALEF.
unsigned fastEmit_X86ISD_SCALEF_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSCALEFPSZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SCALEF_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSCALEFPDZrb, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SCALEF_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v16f32: return fastEmit_X86ISD_SCALEF_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_SCALEF_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHLD.
unsigned fastEmit_X86ISD_SHLD_MVT_i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rri(X86::SHLD16rri8, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHLD_MVT_i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rri(X86::SHLD32rri8, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHLD_MVT_i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rri(X86::SHLD64rri8, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHLD_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_X86ISD_SHLD_MVT_i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i32: return fastEmit_X86ISD_SHLD_MVT_i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i64: return fastEmit_X86ISD_SHLD_MVT_i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHRD.
unsigned fastEmit_X86ISD_SHRD_MVT_i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_rri(X86::SHRD16rri8, &X86::GR16RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHRD_MVT_i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_rri(X86::SHRD32rri8, &X86::GR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHRD_MVT_i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_rri(X86::SHRD64rri8, &X86::GR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHRD_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_X86ISD_SHRD_MVT_i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i32: return fastEmit_X86ISD_SHRD_MVT_i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i64: return fastEmit_X86ISD_SHRD_MVT_i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHUF128.
unsigned fastEmit_X86ISD_SHUF128_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VSHUFI32X4Z256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v16i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSHUFI32X4Zrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VSHUFI64X2Z256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v8i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSHUFI64X2Zrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VSHUFF32X4Z256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSHUFF32X4Zrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VSHUFF64X2Z256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSHUFF64X2Zrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUF128_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_SHUF128_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i32: return fastEmit_X86ISD_SHUF128_MVT_v16i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return fastEmit_X86ISD_SHUF128_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i64: return fastEmit_X86ISD_SHUF128_MVT_v8i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_SHUF128_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_SHUF128_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_SHUF128_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_SHUF128_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHUFP.
unsigned fastEmit_X86ISD_SHUFP_MVT_v4i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::SHUFPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPSYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v16i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
return fastEmitInst_rri(X86::VSHUFPSZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v2i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::SHUFPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPDYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v8i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
return fastEmitInst_rri(X86::VSHUFPDZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::SHUFPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPSrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPSYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSHUFPSZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::SHUFPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPDrri, &X86::VR128RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VSHUFPDYrri, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VSHUFPDZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_SHUFP_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_SHUFP_MVT_v4i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return fastEmit_X86ISD_SHUFP_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i32: return fastEmit_X86ISD_SHUFP_MVT_v16i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2i64: return fastEmit_X86ISD_SHUFP_MVT_v2i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return fastEmit_X86ISD_SHUFP_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i64: return fastEmit_X86ISD_SHUFP_MVT_v8i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f32: return fastEmit_X86ISD_SHUFP_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_SHUFP_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_SHUFP_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_SHUFP_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_SHUFP_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_SHUFP_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::VALIGN.
unsigned fastEmit_X86ISD_VALIGN_MVT_v4i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGNDZ128rri, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGNDZ256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v16i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VALIGNDZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v2i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGNQZ128rri, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGNQZ256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v8i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VALIGNQZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGND_FPZ128rri, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGND_FPZ256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v16f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VALIGND_FPZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGNQ_FPZ128rri, &X86::VR128XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_rri(X86::VALIGNQ_FPZ256rri, &X86::VR256XRegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_MVT_v8f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_rri(X86::VALIGNQ_FPZrri, &X86::VR512RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VALIGN_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_VALIGN_MVT_v4i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return fastEmit_X86ISD_VALIGN_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i32: return fastEmit_X86ISD_VALIGN_MVT_v16i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2i64: return fastEmit_X86ISD_VALIGN_MVT_v2i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return fastEmit_X86ISD_VALIGN_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i64: return fastEmit_X86ISD_VALIGN_MVT_v8i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f32: return fastEmit_X86ISD_VALIGN_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_VALIGN_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16f32: return fastEmit_X86ISD_VALIGN_MVT_v16f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return fastEmit_X86ISD_VALIGN_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_VALIGN_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f64: return fastEmit_X86ISD_VALIGN_MVT_v8f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERM2X128.
unsigned fastEmit_X86ISD_VPERM2X128_MVT_v32i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2I128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2F128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERM2X128_MVT_v16i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2I128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2F128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERM2X128_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2I128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2F128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERM2X128_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX() && !Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2F128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_rri(X86::VPERM2I128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERM2X128_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VPERM2F128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERM2X128_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VPERM2F128rr, &X86::VR256RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERM2X128_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v32i8: return fastEmit_X86ISD_VPERM2X128_MVT_v32i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i16: return fastEmit_X86ISD_VPERM2X128_MVT_v16i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return fastEmit_X86ISD_VPERM2X128_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return fastEmit_X86ISD_VPERM2X128_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return fastEmit_X86ISD_VPERM2X128_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return fastEmit_X86ISD_VPERM2X128_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_rri(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) override {
if (VT == MVT::i8 && Predicate_i8immZExt5(imm2))
if (unsigned Reg = fastEmit_rri_Predicate_i8immZExt5(VT, RetVT, Opcode, Op0, Op0IsKill, Op1, Op1IsKill, imm2))
return Reg;
if (VT == MVT::i8 && Predicate_i8immZExt3(imm2))
if (unsigned Reg = fastEmit_rri_Predicate_i8immZExt3(VT, RetVT, Opcode, Op0, Op0IsKill, Op1, Op1IsKill, imm2))
return Reg;
switch (Opcode) {
case X86ISD::BLENDI: return fastEmit_X86ISD_BLENDI_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::CMPM: return fastEmit_X86ISD_CMPM_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::CMPMU: return fastEmit_X86ISD_CMPMU_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::CMPP: return fastEmit_X86ISD_CMPP_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FADD_RND: return fastEmit_X86ISD_FADD_RND_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FDIV_RND: return fastEmit_X86ISD_FDIV_RND_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FMUL_RND: return fastEmit_X86ISD_FMUL_RND_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FSETCC: return fastEmit_X86ISD_FSETCC_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FSUB_RND: return fastEmit_X86ISD_FSUB_RND_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::INSERTPS: return fastEmit_X86ISD_INSERTPS_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SCALEF: return fastEmit_X86ISD_SCALEF_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHLD: return fastEmit_X86ISD_SHLD_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHRD: return fastEmit_X86ISD_SHRD_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHUF128: return fastEmit_X86ISD_SHUF128_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHUFP: return fastEmit_X86ISD_SHUFP_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::VALIGN: return fastEmit_X86ISD_VALIGN_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::VPERM2X128: return fastEmit_X86ISD_VPERM2X128_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSETCC.
unsigned fastEmit_X86ISD_FSETCC_MVT_f32_rri_Predicate_i8immZExt5(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VCMPSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSETCC_MVT_f64_rri_Predicate_i8immZExt5(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::VCMPSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSETCC_rri_Predicate_i8immZExt5(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FSETCC_MVT_f32_rri_Predicate_i8immZExt5(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::f64: return fastEmit_X86ISD_FSETCC_MVT_f64_rri_Predicate_i8immZExt5(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_rri_Predicate_i8immZExt5(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (Opcode) {
case X86ISD::FSETCC: return fastEmit_X86ISD_FSETCC_rri_Predicate_i8immZExt5(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSETCC.
unsigned fastEmit_X86ISD_FSETCC_MVT_f32_rri_Predicate_i8immZExt3(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::CMPSSrr, &X86::FR32RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSETCC_MVT_f64_rri_Predicate_i8immZExt3(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_rri(X86::CMPSDrr, &X86::FR64RegClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned fastEmit_X86ISD_FSETCC_rri_Predicate_i8immZExt3(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::f32: return fastEmit_X86ISD_FSETCC_MVT_f32_rri_Predicate_i8immZExt3(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::f64: return fastEmit_X86ISD_FSETCC_MVT_f64_rri_Predicate_i8immZExt3(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_rri_Predicate_i8immZExt3(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (Opcode) {
case X86ISD::FSETCC: return fastEmit_X86ISD_FSETCC_rri_Predicate_i8immZExt3(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned fastEmit_ISD_ADD_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::ADD8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::ADD16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::ADD32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ADD_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_ADD_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_ADD_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned fastEmit_ISD_AND_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::AND8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::AND16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::AND32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_AND_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_AND_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_AND_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::EXTRACT_VECTOR_ELT.
unsigned fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PEXTRDrr, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPEXTRDrr, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PEXTRQrr, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPEXTRQrr, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_EXTRACT_VECTOR_ELT_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned fastEmit_ISD_MUL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::IMUL16rri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_MUL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::IMUL32rri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_MUL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_MUL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_MUL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned fastEmit_ISD_OR_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::OR8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::OR16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::OR32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_OR_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_OR_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_OR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ROTL.
unsigned fastEmit_ISD_ROTL_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::ROL8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::ROL16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::ROL32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTL_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::ROL64ri, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTL_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPROLDZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPROLDZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPROLDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPROLQZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPROLQZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPROLQZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ROTL_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_ROTL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_ROTL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return fastEmit_ISD_ROTL_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i32: return fastEmit_ISD_ROTL_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i32: return fastEmit_ISD_ROTL_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_ISD_ROTL_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_ISD_ROTL_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_ISD_ROTL_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_ISD_ROTL_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ROTR.
unsigned fastEmit_ISD_ROTR_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::ROR8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTR_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::ROR16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::ROR32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTR_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::ROR64ri, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ROTR_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPRORDZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPRORDZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPRORDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPRORQZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPRORQZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPRORQZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_ROTR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_ROTR_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_ROTR_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_ROTR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return fastEmit_ISD_ROTR_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i32: return fastEmit_ISD_ROTR_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i32: return fastEmit_ISD_ROTR_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_ISD_ROTR_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_ISD_ROTR_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_ISD_ROTR_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_ISD_ROTR_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SHL.
unsigned fastEmit_ISD_SHL_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::SHL8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SHL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::SHL16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SHL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::SHL32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SHL_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::SHL64ri, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SHL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SHL_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_SHL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_SHL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return fastEmit_ISD_SHL_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SINT_TO_FP.
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTDQ2PSZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f32_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTQQ2PSZrrb, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f64_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTQQ2PDZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_SINT_TO_FP_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (RetVT.SimpleTy) {
case MVT::v8f32: return fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f32_ri(Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_ISD_SINT_TO_FP_MVT_v8i64_MVT_v8f64_ri(Op0, Op0IsKill, imm1);
default: return 0;
}
}
unsigned fastEmit_ISD_SINT_TO_FP_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v16i32: return fastEmit_ISD_SINT_TO_FP_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_ISD_SINT_TO_FP_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SRA.
unsigned fastEmit_ISD_SRA_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::SAR8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRA_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::SAR16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRA_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::SAR32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRA_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::SAR64ri, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRA_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SRA_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_SRA_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_SRA_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return fastEmit_ISD_SRA_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SRL.
unsigned fastEmit_ISD_SRL_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::SHR8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::SHR16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::SHR32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRL_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::SHR64ri, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SRL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SRL_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_SRL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_SRL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return fastEmit_ISD_SRL_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned fastEmit_ISD_SUB_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::SUB8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::SUB16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::SUB32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_SUB_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_SUB_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_SUB_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::UINT_TO_FP.
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTUDQ2PSZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f32_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTUQQ2PSZrrb, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f64_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTUQQ2PDZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_ISD_UINT_TO_FP_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (RetVT.SimpleTy) {
case MVT::v8f32: return fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f32_ri(Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_ISD_UINT_TO_FP_MVT_v8i64_MVT_v8f64_ri(Op0, Op0IsKill, imm1);
default: return 0;
}
}
unsigned fastEmit_ISD_UINT_TO_FP_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v16i32: return fastEmit_ISD_UINT_TO_FP_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_ISD_UINT_TO_FP_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned fastEmit_ISD_XOR_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_ri(X86::XOR8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::XOR16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::XOR32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_XOR_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_ISD_XOR_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_ISD_XOR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::BEXTR.
unsigned fastEmit_X86ISD_BEXTR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasTBM())) {
return fastEmitInst_ri(X86::BEXTRI32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_BEXTR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_BEXTR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned fastEmit_X86ISD_CMP_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP8ri, &X86::GR8RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP16ri, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP32ri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_X86ISD_CMP_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return fastEmit_X86ISD_CMP_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return fastEmit_X86ISD_CMP_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::FP_TO_SINT_RND.
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTPS2QQZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v16f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTPS2DQZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i32_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTPD2DQZrrb, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i64_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTPD2QQZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i32_ri(Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_MVT_v8i64_ri(Op0, Op0IsKill, imm1);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_SINT_RND_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8f32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16f32: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v16f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_X86ISD_FP_TO_SINT_RND_MVT_v8f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::FP_TO_UINT_RND.
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTPS2UQQZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v16f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTPS2UDQZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i32_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTPD2UDQZrrb, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i64_ri(unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::VCVTPD2UQQZrrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (RetVT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i32_ri(Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_MVT_v8i64_ri(Op0, Op0IsKill, imm1);
default: return 0;
}
}
unsigned fastEmit_X86ISD_FP_TO_UINT_RND_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8f32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16f32: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v16f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_X86ISD_FP_TO_UINT_RND_MVT_v8f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSQRT_RND.
unsigned fastEmit_X86ISD_FSQRT_RND_MVT_v16f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VSQRTPSZrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FSQRT_RND_MVT_v8f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VSQRTPDZrb, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_FSQRT_RND_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v16f32: return fastEmit_X86ISD_FSQRT_RND_MVT_v16f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_X86ISD_FSQRT_RND_MVT_v8f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PEXTRB.
unsigned fastEmit_X86ISD_PEXTRB_MVT_v16i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasSSE41() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PEXTRBrr, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPEXTRBrr, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PEXTRB_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v16i8: return fastEmit_X86ISD_PEXTRB_MVT_v16i8_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PEXTRW.
unsigned fastEmit_X86ISD_PEXTRW_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PEXTRWri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPEXTRWri, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PEXTRW_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_PEXTRW_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFD.
unsigned fastEmit_X86ISD_PSHUFD_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSHUFDZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSHUFDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPSHUFDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFD_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSHUFDZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_ri(X86::VPSHUFDYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFD_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSHUFDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFD_MVT_v4f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSHUFDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPSHUFDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFD_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v4i32: return fastEmit_X86ISD_PSHUFD_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i32: return fastEmit_X86ISD_PSHUFD_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_X86ISD_PSHUFD_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4f32: return fastEmit_X86ISD_PSHUFD_MVT_v4f32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFHW.
unsigned fastEmit_X86ISD_PSHUFHW_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSHUFHWZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSHUFHWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPSHUFHWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFHW_MVT_v16i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSHUFHWZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_ri(X86::VPSHUFHWYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFHW_MVT_v32i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSHUFHWZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFHW_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_PSHUFHW_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i16: return fastEmit_X86ISD_PSHUFHW_MVT_v16i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i16: return fastEmit_X86ISD_PSHUFHW_MVT_v32i16_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFLW.
unsigned fastEmit_X86ISD_PSHUFLW_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSHUFLWZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSHUFLWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPSHUFLWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFLW_MVT_v16i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSHUFLWZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_ri(X86::VPSHUFLWYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFLW_MVT_v32i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSHUFLWZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_PSHUFLW_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_PSHUFLW_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i16: return fastEmit_X86ISD_PSHUFLW_MVT_v16i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i16: return fastEmit_X86ISD_PSHUFLW_MVT_v32i16_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VFPROUND.
unsigned fastEmit_X86ISD_VFPROUND_MVT_v8f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VCVTPD2PSZrrb, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VFPROUND_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8f64: return fastEmit_X86ISD_VFPROUND_MVT_v8f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERMI.
unsigned fastEmit_X86ISD_VPERMI_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPERMQZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_ri(X86::VPERMQYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMI_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPERMQZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMI_MVT_v4f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPERMPDZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2())) {
return fastEmitInst_ri(X86::VPERMPDYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMI_MVT_v8f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPERMPDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMI_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v4i64: return fastEmit_X86ISD_VPERMI_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_VPERMI_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4f64: return fastEmit_X86ISD_VPERMI_MVT_v4f64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_X86ISD_VPERMI_MVT_v8f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERMILPI.
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPSYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
return fastEmitInst_ri(X86::VPERMILPSZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPDYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
return fastEmitInst_ri(X86::VPERMILPDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v4f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPSri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v8f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPSYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v16f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16f32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPERMILPSZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v2f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v4f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::VPERMILPDYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_MVT_v8f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8f64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPERMILPDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VPERMILPI_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i32: return fastEmit_X86ISD_VPERMILPI_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_X86ISD_VPERMILPI_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_X86ISD_VPERMILPI_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_X86ISD_VPERMILPI_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_VPERMILPI_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4f32: return fastEmit_X86ISD_VPERMILPI_MVT_v4f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f32: return fastEmit_X86ISD_VPERMILPI_MVT_v8f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16f32: return fastEmit_X86ISD_VPERMILPI_MVT_v16f32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2f64: return fastEmit_X86ISD_VPERMILPI_MVT_v2f64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4f64: return fastEmit_X86ISD_VPERMILPI_MVT_v4f64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f64: return fastEmit_X86ISD_VPERMILPI_MVT_v8f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSHLDQ.
unsigned fastEmit_X86ISD_VSHLDQ_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSLLDQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLDQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLDQ_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLDQYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLDQ_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_VSHLDQ_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_X86ISD_VSHLDQ_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSHLI.
unsigned fastEmit_X86ISD_VSHLI_MVT_v8i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::KSHIFTLBri, &X86::VK8RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v16i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::KSHIFTLWri, &X86::VK16RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v32i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::KSHIFTLDri, &X86::VK32RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v64i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::KSHIFTLQri, &X86::VK64RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSLLWZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSLLWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v16i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSLLWZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLWYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v32i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSLLWZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLDZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSLLDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLDZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLDYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSLLDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLQZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSLLQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLQZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSLLQYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSLLQZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSHLI_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i1: return fastEmit_X86ISD_VSHLI_MVT_v8i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i1: return fastEmit_X86ISD_VSHLI_MVT_v16i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i1: return fastEmit_X86ISD_VSHLI_MVT_v32i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v64i1: return fastEmit_X86ISD_VSHLI_MVT_v64i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i16: return fastEmit_X86ISD_VSHLI_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i16: return fastEmit_X86ISD_VSHLI_MVT_v16i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i16: return fastEmit_X86ISD_VSHLI_MVT_v32i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i32: return fastEmit_X86ISD_VSHLI_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i32: return fastEmit_X86ISD_VSHLI_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_X86ISD_VSHLI_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_X86ISD_VSHLI_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_X86ISD_VSHLI_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_VSHLI_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSRAI.
unsigned fastEmit_X86ISD_VSRAI_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSRAWZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSRAWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRAWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v16i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSRAWZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRAWYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v32i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSRAWZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRADZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSRADri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRADri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRADZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRADYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSRADZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRAQZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRAQZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSRAQZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRAI_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return fastEmit_X86ISD_VSRAI_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i16: return fastEmit_X86ISD_VSRAI_MVT_v16i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i16: return fastEmit_X86ISD_VSRAI_MVT_v32i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i32: return fastEmit_X86ISD_VSRAI_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i32: return fastEmit_X86ISD_VSRAI_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_X86ISD_VSRAI_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_X86ISD_VSRAI_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_X86ISD_VSRAI_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_VSRAI_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSRLDQ.
unsigned fastEmit_X86ISD_VSRLDQ_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSRLDQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLDQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLDQ_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLDQYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLDQ_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v2i64: return fastEmit_X86ISD_VSRLDQ_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_X86ISD_VSRLDQ_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VSRLI.
unsigned fastEmit_X86ISD_VSRLI_MVT_v8i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::KSHIFTRBri, &X86::VK8RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v16i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i1)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::KSHIFTRWri, &X86::VK16RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v32i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i1)
return 0;
if ((Subtarget->hasDQI())) {
return fastEmitInst_ri(X86::KSHIFTRDri, &X86::VK32RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v64i1_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v64i1)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::KSHIFTRQri, &X86::VK64RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSRLWZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSRLWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLWri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v16i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
if ((Subtarget->hasVLX()) && (Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSRLWZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLWYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v32i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v32i16)
return 0;
if ((Subtarget->hasBWI())) {
return fastEmitInst_ri(X86::VPSRLWZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLDZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSRLDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLDri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLDZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLDYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v16i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v16i32)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSRLDZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLQZ128ri, &X86::VR128XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2() && !Subtarget->hasAVX())) {
return fastEmitInst_ri(X86::PSRLQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLQri, &X86::VR128RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX512()) && (Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLQZ256ri, &X86::VR256XRegClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasAVX2()) && (!Subtarget->hasVLX())) {
return fastEmitInst_ri(X86::VPSRLQYri, &X86::VR256RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_MVT_v8i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i64)
return 0;
if ((Subtarget->hasAVX512())) {
return fastEmitInst_ri(X86::VPSRLQZri, &X86::VR512RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_VSRLI_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i1: return fastEmit_X86ISD_VSRLI_MVT_v8i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i1: return fastEmit_X86ISD_VSRLI_MVT_v16i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i1: return fastEmit_X86ISD_VSRLI_MVT_v32i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v64i1: return fastEmit_X86ISD_VSRLI_MVT_v64i1_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i16: return fastEmit_X86ISD_VSRLI_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i16: return fastEmit_X86ISD_VSRLI_MVT_v16i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v32i16: return fastEmit_X86ISD_VSRLI_MVT_v32i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i32: return fastEmit_X86ISD_VSRLI_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i32: return fastEmit_X86ISD_VSRLI_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v16i32: return fastEmit_X86ISD_VSRLI_MVT_v16i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return fastEmit_X86ISD_VSRLI_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4i64: return fastEmit_X86ISD_VSRLI_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8i64: return fastEmit_X86ISD_VSRLI_MVT_v8i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_ri(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) override {
if (VT == MVT::i16 && Predicate_i16immSExt8(imm1))
if (unsigned Reg = fastEmit_ri_Predicate_i16immSExt8(VT, RetVT, Opcode, Op0, Op0IsKill, imm1))
return Reg;
if (VT == MVT::i32 && Predicate_i32immSExt8(imm1))
if (unsigned Reg = fastEmit_ri_Predicate_i32immSExt8(VT, RetVT, Opcode, Op0, Op0IsKill, imm1))
return Reg;
if (VT == MVT::i64 && Predicate_i64immSExt8(imm1))
if (unsigned Reg = fastEmit_ri_Predicate_i64immSExt8(VT, RetVT, Opcode, Op0, Op0IsKill, imm1))
return Reg;
if (VT == MVT::i64 && Predicate_i64immSExt32(imm1))
if (unsigned Reg = fastEmit_ri_Predicate_i64immSExt32(VT, RetVT, Opcode, Op0, Op0IsKill, imm1))
return Reg;
switch (Opcode) {
case ISD::ADD: return fastEmit_ISD_ADD_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return fastEmit_ISD_AND_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::EXTRACT_VECTOR_ELT: return fastEmit_ISD_EXTRACT_VECTOR_ELT_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return fastEmit_ISD_MUL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return fastEmit_ISD_OR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::ROTL: return fastEmit_ISD_ROTL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::ROTR: return fastEmit_ISD_ROTR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SHL: return fastEmit_ISD_SHL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SINT_TO_FP: return fastEmit_ISD_SINT_TO_FP_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SRA: return fastEmit_ISD_SRA_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SRL: return fastEmit_ISD_SRL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return fastEmit_ISD_SUB_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::UINT_TO_FP: return fastEmit_ISD_UINT_TO_FP_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return fastEmit_ISD_XOR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::BEXTR: return fastEmit_X86ISD_BEXTR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return fastEmit_X86ISD_CMP_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::FP_TO_SINT_RND: return fastEmit_X86ISD_FP_TO_SINT_RND_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::FP_TO_UINT_RND: return fastEmit_X86ISD_FP_TO_UINT_RND_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::FSQRT_RND: return fastEmit_X86ISD_FSQRT_RND_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PEXTRB: return fastEmit_X86ISD_PEXTRB_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PEXTRW: return fastEmit_X86ISD_PEXTRW_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PSHUFD: return fastEmit_X86ISD_PSHUFD_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PSHUFHW: return fastEmit_X86ISD_PSHUFHW_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PSHUFLW: return fastEmit_X86ISD_PSHUFLW_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VFPROUND: return fastEmit_X86ISD_VFPROUND_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VPERMI: return fastEmit_X86ISD_VPERMI_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VPERMILPI: return fastEmit_X86ISD_VPERMILPI_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VSHLDQ: return fastEmit_X86ISD_VSHLDQ_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VSHLI: return fastEmit_X86ISD_VSHLI_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VSRAI: return fastEmit_X86ISD_VSRAI_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VSRLDQ: return fastEmit_X86ISD_VSRLDQ_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VSRLI: return fastEmit_X86ISD_VSRLI_ri(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned fastEmit_ISD_ADD_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::ADD16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_ADD_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned fastEmit_ISD_AND_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::AND16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_AND_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned fastEmit_ISD_MUL_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::IMUL16rri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_MUL_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_MUL_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned fastEmit_ISD_OR_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::OR16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_OR_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned fastEmit_ISD_SUB_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::SUB16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_SUB_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned fastEmit_ISD_XOR_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_ri(X86::XOR16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_ISD_XOR_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::BT.
unsigned fastEmit_X86ISD_BT_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::BT16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_BT_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_X86ISD_BT_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned fastEmit_X86ISD_CMP_MVT_i16_ri_Predicate_i16immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP16ri8, &X86::GR16RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return fastEmit_X86ISD_CMP_MVT_i16_ri_Predicate_i16immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_ri_Predicate_i16immSExt8(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (Opcode) {
case ISD::ADD: return fastEmit_ISD_ADD_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return fastEmit_ISD_AND_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return fastEmit_ISD_MUL_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return fastEmit_ISD_OR_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return fastEmit_ISD_SUB_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return fastEmit_ISD_XOR_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::BT: return fastEmit_X86ISD_BT_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return fastEmit_X86ISD_CMP_ri_Predicate_i16immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned fastEmit_ISD_ADD_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::ADD32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_ADD_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned fastEmit_ISD_AND_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::AND32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_AND_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned fastEmit_ISD_MUL_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::IMUL32rri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_MUL_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_MUL_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned fastEmit_ISD_OR_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::OR32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_OR_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned fastEmit_ISD_SUB_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::SUB32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_SUB_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned fastEmit_ISD_XOR_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::XOR32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_ISD_XOR_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::BT.
unsigned fastEmit_X86ISD_BT_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::BT32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_BT_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_BT_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned fastEmit_X86ISD_CMP_MVT_i32_ri_Predicate_i32immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP32ri8, &X86::GR32RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return fastEmit_X86ISD_CMP_MVT_i32_ri_Predicate_i32immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_ri_Predicate_i32immSExt8(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (Opcode) {
case ISD::ADD: return fastEmit_ISD_ADD_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return fastEmit_ISD_AND_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return fastEmit_ISD_MUL_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return fastEmit_ISD_OR_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return fastEmit_ISD_SUB_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return fastEmit_ISD_XOR_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::BT: return fastEmit_X86ISD_BT_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return fastEmit_X86ISD_CMP_ri_Predicate_i32immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned fastEmit_ISD_ADD_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::ADD64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_ADD_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned fastEmit_ISD_AND_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::AND64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_AND_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned fastEmit_ISD_MUL_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::IMUL64rri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_MUL_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_MUL_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned fastEmit_ISD_OR_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::OR64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_OR_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned fastEmit_ISD_SUB_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::SUB64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_SUB_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned fastEmit_ISD_XOR_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::XOR64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_XOR_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::BT.
unsigned fastEmit_X86ISD_BT_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::BT64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_BT_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_X86ISD_BT_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned fastEmit_X86ISD_CMP_MVT_i64_ri_Predicate_i64immSExt8(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP64ri8, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_X86ISD_CMP_MVT_i64_ri_Predicate_i64immSExt8(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_ri_Predicate_i64immSExt8(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (Opcode) {
case ISD::ADD: return fastEmit_ISD_ADD_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return fastEmit_ISD_AND_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return fastEmit_ISD_MUL_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return fastEmit_ISD_OR_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return fastEmit_ISD_SUB_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return fastEmit_ISD_XOR_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::BT: return fastEmit_X86ISD_BT_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return fastEmit_X86ISD_CMP_ri_Predicate_i64immSExt8(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned fastEmit_ISD_ADD_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::ADD64ri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_ADD_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_ADD_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned fastEmit_ISD_AND_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::AND64ri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_AND_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_AND_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned fastEmit_ISD_MUL_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::IMUL64rri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_MUL_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_MUL_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned fastEmit_ISD_OR_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::OR64ri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_OR_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_OR_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned fastEmit_ISD_SUB_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::SUB64ri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_SUB_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_SUB_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned fastEmit_ISD_XOR_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_ri(X86::XOR64ri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_ISD_XOR_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_ISD_XOR_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::BEXTR.
unsigned fastEmit_X86ISD_BEXTR_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasTBM())) {
return fastEmitInst_ri(X86::BEXTRI64ri, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned fastEmit_X86ISD_BEXTR_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_X86ISD_BEXTR_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned fastEmit_X86ISD_CMP_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_ri(X86::CMP64ri32, &X86::GR64RegClass, Op0, Op0IsKill, imm1);
}
unsigned fastEmit_X86ISD_CMP_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return fastEmit_X86ISD_CMP_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (Opcode) {
case ISD::ADD: return fastEmit_ISD_ADD_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return fastEmit_ISD_AND_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return fastEmit_ISD_MUL_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return fastEmit_ISD_OR_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return fastEmit_ISD_SUB_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return fastEmit_ISD_XOR_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::BEXTR: return fastEmit_X86ISD_BEXTR_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return fastEmit_X86ISD_CMP_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::Constant.
unsigned fastEmit_ISD_Constant_MVT_i8_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return fastEmitInst_i(X86::MOV8ri, &X86::GR8RegClass, imm0);
}
unsigned fastEmit_ISD_Constant_MVT_i16_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return fastEmitInst_i(X86::MOV16ri, &X86::GR16RegClass, imm0);
}
unsigned fastEmit_ISD_Constant_MVT_i32_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return fastEmitInst_i(X86::MOV32ri, &X86::GR32RegClass, imm0);
}
unsigned fastEmit_ISD_Constant_MVT_i64_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return fastEmitInst_i(X86::MOV64ri, &X86::GR64RegClass, imm0);
}
unsigned fastEmit_ISD_Constant_i(MVT VT, MVT RetVT, uint64_t imm0) {
switch (VT.SimpleTy) {
case MVT::i8: return fastEmit_ISD_Constant_MVT_i8_i(RetVT, imm0);
case MVT::i16: return fastEmit_ISD_Constant_MVT_i16_i(RetVT, imm0);
case MVT::i32: return fastEmit_ISD_Constant_MVT_i32_i(RetVT, imm0);
case MVT::i64: return fastEmit_ISD_Constant_MVT_i64_i(RetVT, imm0);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned fastEmit_i(MVT VT, MVT RetVT, unsigned Opcode, uint64_t imm0) override {
switch (Opcode) {
case ISD::Constant: return fastEmit_ISD_Constant_i(VT, RetVT, imm0);
default: return 0;
}
}
| [
"agarny@hellix.com"
] | agarny@hellix.com |
862f2904a24eef2b2b1b2dcd4e29e415e9338c1c | 2de74aee70593f9cf62f43e1aa2183240b27ce34 | /src/malware_definition_children/keylogger_definition.h | 4bd4dc221ad6d6c934f0cf63afe6fba6333384f8 | [] | no_license | gardng59/malware-analyzer | 6f77a604184f819233faa6ef65a7f24e051aa288 | 68ce65b82bd2014ff27394ba7d5b7c6a2056bda4 | refs/heads/master | 2021-07-11T16:29:46.070823 | 2018-12-11T19:21:09 | 2018-12-11T19:21:09 | 136,522,562 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 336 | h | #include "../import_data.h"
#include "../malware_definition.h"
#include <string>
#include <vector>
#ifndef KEYLOGGER_DEFINITION_H
#define KEYLOGGER_DEFINITION_H
class KeyloggerDefinition: public MalwareDefinition
{
public:
KeyloggerDefinition();
double calculateProbability(std::vector<ImportData*> imports);
};
#endif
| [
"gardng59@uwosh.edu"
] | gardng59@uwosh.edu |
0f1aaba6c8d3e2c554a9f46cfbdc31cce82920a7 | 796f8851d2509455dc2f89592a51bcd8d022948d | /20190101-1주차-1일차/문지현/C.cpp | 47a127f31177461d757065f99572f34f83dc0e52 | [] | no_license | rhythm-union/2019-algorithm-study | ade8c4adedea0acf54f1183a1e6a3c8eaed814f0 | 92e6ad25b0cf9614f5f7da734a547d12302c0491 | refs/heads/master | 2020-04-14T02:24:44.056689 | 2019-02-15T17:56:45 | 2019-02-15T17:56:45 | 163,582,114 | 9 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 262 | cpp | #include <stdio.h>
#include <iostream>
using namespace std;
int main(){
int n = 0;
scanf("%d", &n);
for(int q = 0; q < n; q++){
string num;
cin>>num;
if(num[num.length()-1]%2 == 0){
printf("even\n");
} else {
printf("odd\n");
}
}
}
| [
"46284684+Ji-Hyeon@users.noreply.github.com"
] | 46284684+Ji-Hyeon@users.noreply.github.com |
7e22bbf89ae6be445770d6c0a2b995ae19f27db4 | 3193fab36a50300d58d8ef5c8a5f19257573efcc | /Session1/313_Super_Ugly_Number.cpp | c7ce5ffa878ef6bd972a8da92c897748efb43d96 | [] | no_license | truthspy/LeetCode | bf04e5e5b6bb872d781ea37f2985ef1561a393b3 | 3c1ac54a10d7cdc42ebdffad2b761c552cb93acb | refs/heads/master | 2021-01-20T18:24:46.914617 | 2016-10-23T10:53:39 | 2016-10-23T10:53:39 | 48,662,072 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 641 | cpp | class Solution {
public:
int nthSuperUglyNumber(int n, vector<int>& primes) {
int k = primes.size();
vector<int> result(n, 1);
vector<int> p(k, 0);
int m = 1;
while(m < n) {
int min = INT_MAX;
for(int i = 0; i < k; i ++) {
if(result[p[i]] * primes[i] < min)
min = result[p[i]] * primes[i];
}
result[m] = min;
for(int i = 0; i < k; i ++) {
if(result[p[i]] * primes[i] == min)
p[i] ++;
}
m ++;
}
return result[n - 1];
}
};
| [
"qirongrong0831@163.com"
] | qirongrong0831@163.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.