Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "if", "(", "VT", ".", "isScalableVector", "(", ")", ")", "break", ";", "assert", "(", "OpVT", ".", "getVectorElementCount", "(", ")", "==", "VT", ".", "getVectorElementCount", "(", ")", "*", "<NUM_LIT>", "&&", "<STR_LIT>", "Expected result vector with half the lanes of its input!", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "assert", "(", "OpVT", ".", "getSizeInBits", "(", ")", "==", "VT", ".", "getSizeInBits", "(", ")", "&&", "<STR_LIT>", "Expected vectors of equal size!", "<STR_LIT>", ")", ";", "<BUGS>", "<BUGE>", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";" ]

[ "else", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "if", "(", "Opcode", "==", "ARM", "::", "SSAT", "||", "Opcode", "==", "ARM", "::", "SSAT16", ")", "Pos", "+=", "<NUM_LIT>", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Pos", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getRegisterEnum", "(", "B", ",", "ARM", "::", "GPRRegClassID", ",", "decodeRm", "(", "insn", ")", ")", ")", ")", ";", "if", "(", "NumOpsAdded", "==", "<NUM_LIT>", ")", "{", "<STR_LIT>", "::", "<STR_LIT>", "Opc", "=", "(", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "unsigned", "ShAmt", "=", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "ShAmt", "==", "<NUM_LIT>", ")", "{", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "ShAmt", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "rtx_insn", "*", "block", "=", "bp", "->", "insert_place", ";", "<FIXE>" ]

[ "label", "=", "bp", "->", "near_label", ";", "if", "(", "!", "label", "&&", "bp", "->", "address", "-", "addr", ">=", "CONDJUMP_MIN", ")", "{", "<BUGS>", "rtx", "block", "=", "bp", "->", "insert_place", ";", "<BUGE>", "if", "(", "GET_CODE", "(", "PATTERN", "(", "block", ")", ")", "==", "RETURN", ")", "block", "=", "PREV_INSN", "(", "block", ")", ";" ]

[ ")", "{" ]

[ "void", "AMDGPUInstPrinter", "::", "printImmediateV216", "(", "uint32_t", "Imm", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O" ]

[ "}" ]

[ "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";" ]

[ "if", "(", "Reg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";" ]

[ "if", "(", "hasDebugInfo", ")", "{", "FrameLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "FrameLabel", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "FrameSize", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "FrameSize", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "FrameSize", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "{", "report_fatal_error", "(", "<STR_LIT>", "Unhandled frame size: ", "<STR_LIT>", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "if", "(", "hasDebugInfo", ")", "{", "std", "::", "vector", "<", "MachineMove", ">", "&", "Moves", "=", "MMI", ".", "getFrameMoves", "(", ")", ";", "MachineLocation", "SPDst", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "MachineLocation", "SPSrc", "(", "MachineLocation", "::", "VirtualFP", ",", "-", "FrameSize", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "FrameLabel", ",", "SPDst", ",", "SPSrc", ")", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";" ]

[ "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "MemOps", ")", ";" ]

[ "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOps", ";", "static", "const", "MCPhysReg", "GPRArgRegs", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "static", "const", "unsigned", "NumGPRArgRegs", "=", "array_lengthof", "(", "GPRArgRegs", ")", ";", "unsigned", "FirstVariadicGPR", "=", "CCInfo", ".", "getFirstUnallocated", "(", "GPRArgRegs", ")", ";", "unsigned", "GPRSaveSize", "=", "<NUM_LIT>", "*", "(", "NumGPRArgRegs", "-", "FirstVariadicGPR", ")", ";", "int", "GPRIdx", "=", "<NUM_LIT>", ";", "if", "(", "GPRSaveSize", "!=", "<NUM_LIT>", ")", "{", "if", "(", "IsWin64", ")", "{", "GPRIdx", "=", "MFI", ".", "CreateFixedObject", "(", "GPRSaveSize", ",", "-", "(", "int", ")", "GPRSaveSize", ",", "false", ")", ";", "if", "(", "GPRSaveSize", "&", "<NUM_LIT>", ")", "MFI", ".", "CreateFixedObject", "(", "<NUM_LIT>", "-", "(", "GPRSaveSize", "&", "<NUM_LIT>", ")", ",", "-", "(", "int", ")", "alignTo", "(", "GPRSaveSize", ",", "<NUM_LIT>", ")", ",", "false", ")", ";", "}", "else", "GPRIdx", "=", "MFI", ".", "CreateStackObject", "(", "GPRSaveSize", ",", "<NUM_LIT>", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "GPRIdx", ",", "PtrVT", ")", ";", "for", "(", "unsigned", "i", "=", "FirstVariadicGPR", ";", "i", "<", "NumGPRArgRegs", ";", "++", "i", ")", "{", "unsigned", "VReg", "=", "MF", ".", "addLiveIn", "(", "GPRArgRegs", "[", "i", "]", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "MVT", "::", "i64", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "Val", ",", "FIN", ",", "IsWin64", "?", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "GPRIdx", ",", "(", "i", "-", "FirstVariadicGPR", ")", "*", "<NUM_LIT>", ")", ":", "MachinePointerInfo", "::", "getStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "i", "*", "<NUM_LIT>", ")", ")", ";", "MemOps", ".", "push_back", "(", "Store", ")", ";", "FIN", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "FIN", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "}", "}", "FuncInfo", "->", "setVarArgsGPRIndex", "(", "GPRIdx", ")", ";", "FuncInfo", "->", "setVarArgsGPRSize", "(", "GPRSaveSize", ")", ";", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "!", "IsWin64", ")", "{", "static", "const", "MCPhysReg", "FPRArgRegs", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "static", "const", "unsigned", "NumFPRArgRegs", "=", "array_lengthof", "(", "FPRArgRegs", ")", ";", "unsigned", "FirstVariadicFPR", "=", "CCInfo", ".", "getFirstUnallocated", "(", "FPRArgRegs", ")", ";", "unsigned", "FPRSaveSize", "=", "<NUM_LIT>", "*", "(", "NumFPRArgRegs", "-", "FirstVariadicFPR", ")", ";", "int", "FPRIdx", "=", "<NUM_LIT>", ";", "if", "(", "FPRSaveSize", "!=", "<NUM_LIT>", ")", "{", "FPRIdx", "=", "MFI", ".", "CreateStackObject", "(", "FPRSaveSize", ",", "<NUM_LIT>", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FPRIdx", ",", "PtrVT", ")", ";", "for", "(", "unsigned", "i", "=", "FirstVariadicFPR", ";", "i", "<", "NumFPRArgRegs", ";", "++", "i", ")", "{", "unsigned", "VReg", "=", "MF", ".", "addLiveIn", "(", "FPRArgRegs", "[", "i", "]", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "MVT", "::", "f128", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "Val", ",", "FIN", ",", "MachinePointerInfo", "::", "getStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "i", "*", "<NUM_LIT>", ")", ")", ";", "MemOps", ".", "push_back", "(", "Store", ")", ";", "FIN", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "FIN", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "}", "}", "FuncInfo", "->", "setVarArgsFPRIndex", "(", "FPRIdx", ")", ";", "FuncInfo", "->", "setVarArgsFPRSize", "(", "FPRSaveSize", ")", ";", "}", "if", "(", "!", "MemOps", ".", "empty", "(", ")", ")", "{" ]

[ "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";" ]

[ "getKillRegState", "(", "IsKill", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "Value", ",", "RegState", "::", "Implicit", "|", "getDefRegState", "(", "IsLoad", ")", ")", ";" ]

[ "}", "unsigned", "NumSubRegs", "=", "getNumSubRegsForSpillOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "NumSubRegs", "*", "<NUM_LIT>", ";", "uint64_t", "Rsrc", "=", "AMDGPU", "::", "RSRC_DATA_FORMAT", "|", "AMDGPU", "::", "RSRC_TID_ENABLE", "|", "<NUM_LIT>", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "getSubReg", "(", "RsrcReg", ",", "AMDGPU", "::", "sub0_sub1", ")", ")", ".", "addReg", "(", "ScratchPtr", ")", ".", "addReg", "(", "RsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "getSubReg", "(", "RsrcReg", ",", "AMDGPU", "::", "sub2", ")", ")", ".", "addImm", "(", "Rsrc", "&", "<NUM_LIT>", ")", ".", "addReg", "(", "RsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "getSubReg", "(", "RsrcReg", ",", "AMDGPU", "::", "sub3", ")", ")", ".", "addImm", "(", "Rsrc", ">>", "<NUM_LIT>", ")", ".", "addReg", "(", "RsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "Offset", "+", "Size", ")", ")", "{", "SOffset", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "MI", ",", "<NUM_LIT>", ")", ";", "if", "(", "SOffset", "==", "AMDGPU", "::", "NoRegister", ")", "{", "RanOutOfSGPRs", "=", "true", ";", "SOffset", "=", "AMDGPU", "::", "SGPR0", ";", "}", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "SOffset", ")", ".", "addReg", "(", "ScratchOffset", ")", ".", "addImm", "(", "Offset", ")", ";", "Offset", "=", "<NUM_LIT>", ";", "}", "if", "(", "RanOutOfSGPRs", ")", "Ctx", ".", "emitError", "(", "<STR_LIT>", "Ran out of SGPRs for spilling VGPRS", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NumSubRegs", ";", "i", "!=", "e", ";", "++", "i", ",", "Offset", "+=", "<NUM_LIT>", ")", "{", "unsigned", "SubReg", "=", "NumSubRegs", ">", "<NUM_LIT>", "?", "getPhysRegSubReg", "(", "Value", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "i", ")", ":", "Value", ";", "bool", "IsKill", "=", "(", "i", "==", "e", "-", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "LoadStoreOp", ")", ")", ".", "addReg", "(", "SubReg", ",", "getDefRegState", "(", "IsLoad", ")", ")", ".", "addReg", "(", "RsrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "SOffset", "," ]

[ ";" ]

[ "IntegerType", "*", "T", "=", "dyn_cast", "<", "IntegerType", ">", "(", "P", ".", "getType", "(", ")", ")", ";", "if", "(", "!", "T", "||", "T", "->", "getBitWidth", "(", ")", ">", "DestBW", ")", "return", "false", ";", "}", "for", "(", "Instruction", "&", "In", ":", "*", "LoopB", ")", "if", "(", "!", "In", ".", "isTerminator", "(", ")", "&&", "!", "isPromotableTo", "(", "&", "In", ",", "DestTy", ")", ")", "return", "false", ";", "std", "::", "vector", "<", "Instruction", "*", ">", "LoopIns", ";", "std", "::", "transform", "(", "LoopB", "->", "begin", "(", ")", ",", "LoopB", "->", "end", "(", ")", ",", "std", "::", "back_inserter", "(", "LoopIns", ")", ",", "[", "]", "(", "Instruction", "&", "In", ")", "{", "return", "&", "In", ";", "}", ")", ";", "for", "(", "Instruction", "*", "In", ":", "LoopIns", ")", "promoteTo", "(", "In", ",", "DestTy", ",", "LoopB", ")", ";", "Instruction", "*", "EndI", "=", "ExitB", "->", "getFirstNonPHI", "(", ")", ";", "BasicBlock", "::", "iterator", "End", "=", "EndI", "?", "EndI", "->", "getIterator", "(", ")", ":", "ExitB", "->", "end", "(", ")", ";", "for", "(", "auto", "I", "=", "ExitB", "->", "begin", "(", ")", ";", "I", "!=", "End", ";", "++", "I", ")", "{", "PHINode", "*", "P", "=", "dyn_cast", "<", "PHINode", ">", "(", "I", ")", ";", "if", "(", "!", "P", ")", "break", ";", "Type", "*", "Ty0", "=", "P", "->", "getIncomingValue", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ";", "Type", "*", "PTy", "=", "P", "->", "getType", "(", ")", ";", "if", "(", "PTy", "!=", "Ty0", ")", "{", "assert", "(", "Ty0", "==", "DestTy", ")", ";", "P", "->", "mutateType", "(", "Ty0", ")", ";", "Value", "*", "T", "=", "IRBuilder", "<", ">", "(", "ExitB", ",", "End", ")", ".", "CreateTrunc", "(", "P", ",", "PTy", ")", ";", "P", "->", "mutateType", "(", "PTy", ")", ";", "P", "->", "replaceAllUsesWith", "(", "T", ")", ";", "P", "->", "mutateType", "(", "Ty0", ")", ";", "cast", "<", "Instruction", ">", "(", "T", ")", "->", "setOperand", "(", "<NUM_LIT>", ",", "P", ")", ";", "}", "}", "return", "true" ]

[ "=", "<NUM_LIT>", ";" ]

[ "def", "J2_jumpt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_db2bce9c", ",", "TypeJ", ">", ",", "Enc_daea09", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable" ]

[ ")", ";" ]

[ "return", "_", "_", "builtin_c6x_sshl", "(", "src1", ",", "src2" ]

[ "let", "OperandType", "=", "<STR_LIT>", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "dispRI", ":", "$", "imm", ",", "ptr_rc_nor0", ":", "$", "reg", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "TII", ",", "MachineModuleInfo", "*", "MMI", ",", "unsigned", "DRegNum", ")", "{" ]

[ "static", "void", "EmitDefCfaRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "DebugLoc", "dl", ",", "const", "TargetInstrInfo", "&" ]

[ "bool", "WebAssemblyLowerBrUnless", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Lowering br_unless **********\\n", "<STR_LIT>", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "auto", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MII", "=", "MBB", ".", "begin", "(", ")", ";", "MII", "!=", "MBB", ".", "end", "(", ")", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "BR_UNLESS", ")", "continue", ";", "Register", "Cond", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "Inverted", "=", "false", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "Cond", ")", ")", "{", "assert", "(", "MRI", ".", "hasOneDef", "(", "Cond", ")", ")", ";", "MachineInstr", "*", "Def", "=", "MRI", ".", "getVRegDef", "(", "Cond", ")", ";", "switch", "(", "Def", "->", "getOpcode", "(", ")", ")", "{", "using", "namespace", "WebAssembly", ";", "case", "EQ_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_F32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_F32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_F32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_F32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_F64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_F64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_F64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_F64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQZ_I32", ":", "{", "Cond", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Def", "->", "eraseFromParent", "(", ")", ";", "Inverted", "=", "true", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "if", "(", "!", "Inverted", ")", "{", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "EQZ_I32", ")", ",", "Tmp", ")", ".", "addReg", "(", "Cond", ")", ";", "MFI", ".", "stackifyVReg", "(", "Tmp", ")", ";", "Cond", "=", "Tmp", ";", "Inverted", "=", "true", ";", "}", "assert", "(", "Inverted", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addReg", "(", "Cond", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "}" ]

[ "vqshl_u32", "(", "uint32x2_t", "_", "_", "a", ",", "int32x2_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_aarch64_uqshlv2si_uus", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "false", ";" ]

[ "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return" ]

[ "<FIXS>", "(", "define_mode_attr", "xdee", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(", "TD", "<STR_LIT>", ")", "(", "DD", "<STR_LIT>", ")", "(", "SD", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "define_mode_attr", "RRer", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(", "TD", "<STR_LIT>", ")", "(", "DD", "<STR_LIT>", ")", "(", "SD", "<STR_LIT>", ")", "]", ")", "(", "define_mode_attr", "f0", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(", "TD", "<STR_LIT>", ")", "(", "DD", "<STR_LIT>", ")", "(", "DD", "<STR_LIT>", ")", "]", ")", "(", "define_mode_attr", "op1", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(", "TD", "<STR_LIT>", ")", "(", "DD", "<STR_LIT>", ")", "(", "SD", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "(", "define_code_attr", "atomic", "[", "(", "and", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "(", "mult", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_mode_attr", "xde", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "]", ")", "<BUGE>", "<BUGS>", "(", "define_mode_attr", "xdee", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_mode_attr", "RRe", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "]", ")", "(", "define_mode_attr", "RXe", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_mode_attr", "Rf", "[", "(", "TF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "]", ")", "<BUGE>" ]

[ "-", "<NUM_LIT>", "}", ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "BDL2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "BDL2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>" ]

[ "}" ]

[ "if", "(", "auto", "USatVal", "=", "detectSSatPattern", "(", "In", ",", "VT", ",", "true", ")", ")", "{", "if", "(", "SVT", "==", "MVT", "::", "i8", "&&", "InSVT", "==", "MVT", "::", "i32", ")", "{", "EVT", "MidVT", "=", "VT", ".", "changeVectorElementType", "(", "MVT", "::", "i16", ")", ";", "SDValue", "Mid", "=", "truncateVectorWithPACK", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MidVT", ",", "USatVal", ",", "DL", ",", "DAG", ",", "Subtarget", ")", ";", "assert", "(", "Mid", "&&", "<STR_LIT>", "Failed to pack!", "<STR_LIT>", ")", ";", "SDValue", "V", "=", "truncateVectorWithPACK", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "VT", ",", "Mid", ",", "DL", ",", "DAG", ",", "Subtarget", ")", ";", "assert", "(", "V", "&&", "<STR_LIT>", "Failed to pack!", "<STR_LIT>", ")", ";", "return", "V", ";", "}", "else", "if", "(", "SVT", "==", "MVT", "::", "i8", "||", "Subtarget", ".", "hasSSE41", "(", ")", ")", "return", "truncateVectorWithPACK", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "VT", ",", "USatVal", ",", "DL", ",", "DAG", ",", "Subtarget", ")", ";", "}", "if", "(", "auto", "SSatVal", "=", "detectSSatPattern", "(", "In", ",", "VT", ")", ")", "return", "truncateVectorWithPACK", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "VT", ",", "SSatVal", ",", "DL", ",", "DAG", ",", "Subtarget", ")", ";", "}", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "TLI", ".", "isTypeLegal", "(", "InVT", ")", "&&", "InVT", ".", "isVector", "(", ")", "&&", "SVT", "!=", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "InSVT", "!=", "MVT", "::", "i16", "||", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", "{", "unsigned", "TruncOpc", "=", "<NUM_LIT>", ";", "SDValue", "SatVal", ";", "if", "(", "auto", "SSatVal", "=", "detectSSatPattern", "(", "In", ",", "VT", ")", ")", "{", "SatVal", "=", "SSatVal", ";", "TruncOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "auto", "USatVal", "=", "detectUSatPattern", "(", "In", ",", "VT", ",", "DAG", ",", "DL", ")", ")", "{", "SatVal", "=", "USatVal", ";", "TruncOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "return", "GR", ".", "getOrCreateConstFP", "(", "VZero", ",", "I", ",", "ResType", ",", "TII", ",", "ZeroAsNull", ")", ";" ]

[ "bool", "ZeroAsNull", "=", "STI", ".", "isOpenCLEnv", "(", ")", ";", "APFloat", "VZero", "=", "getZeroFP", "(", "GR", ".", "getTypeForSPIRVType", "(", "ResType", ")", ")", ";", "if", "(", "ResType", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "GR", ".", "getOrCreateConstVector", "(", "VZero", ",", "I", ",", "ResType", ",", "TII", ",", "ZeroAsNull", ")", ";" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr" ]

[ "<NUM_LIT>", ")", "]" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int" ]

[ "otype", ";" ]

[ "class", "TPCInstVector", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "bits", "<", "<NUM_LIT>", ">", "otype", ">", ":", "VectorInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OperandType", "=" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "VDQ", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "VDQ", "(", "not", ":", "VDQ", "(", "match_operand", ":", "VDQ", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "VDQ", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned" ]

[ "Other", ".", "SgprScores", "[", "J", "]", ")", ";" ]

[ "const", "unsigned", "OldEvents", "=", "PendingEvents", "&", "WaitEventMaskForInst", "[", "T", "]", ";", "const", "unsigned", "OtherEvents", "=", "Other", ".", "PendingEvents", "&", "WaitEventMaskForInst", "[", "T", "]", ";", "if", "(", "OtherEvents", "&", "~", "OldEvents", ")", "StrictDom", "=", "true", ";", "PendingEvents", "|=", "OtherEvents", ";", "const", "unsigned", "MyPending", "=", "ScoreUBs", "[", "T", "]", "-", "ScoreLBs", "[", "T", "]", ";", "const", "unsigned", "OtherPending", "=", "Other", ".", "ScoreUBs", "[", "T", "]", "-", "Other", ".", "ScoreLBs", "[", "T", "]", ";", "const", "unsigned", "NewUB", "=", "ScoreLBs", "[", "T", "]", "+", "std", "::", "max", "(", "MyPending", ",", "OtherPending", ")", ";", "if", "(", "NewUB", "<", "ScoreLBs", "[", "T", "]", ")", "report_fatal_error", "(", "<STR_LIT>", "waitcnt score overflow", "<STR_LIT>", ")", ";", "MergeInfo", "M", ";", "M", ".", "OldLB", "=", "ScoreLBs", "[", "T", "]", ";", "M", ".", "OtherLB", "=", "Other", ".", "ScoreLBs", "[", "T", "]", ";", "M", ".", "MyShift", "=", "NewUB", "-", "ScoreUBs", "[", "T", "]", ";", "M", ".", "OtherShift", "=", "NewUB", "-", "Other", ".", "ScoreUBs", "[", "T", "]", ";", "ScoreUBs", "[", "T", "]", "=", "NewUB", ";", "StrictDom", "|=", "mergeScore", "(", "M", ",", "LastFlat", "[", "T", "]", ",", "Other", ".", "LastFlat", "[", "T", "]", ")", ";", "for", "(", "int", "J", "=", "<NUM_LIT>", ";", "J", "<=", "VgprUB", ";", "J", "++", ")", "StrictDom", "|=", "mergeScore", "(", "M", ",", "VgprScores", "[", "T", "]", "[", "J", "]", ",", "Other", ".", "VgprScores", "[", "T", "]", "[", "J", "]", ")", ";", "if", "(", "T", "==", "SmemAccessCounter", ")", "{", "for", "(", "int", "J", "=", "<NUM_LIT>", ";", "J", "<=", "SgprUB", ";", "J", "++", ")", "StrictDom", "|=", "mergeScore", "(", "M", ",", "SgprScores", "[", "J", "]", "," ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "}" ]

[ "unsigned", "Hexagon_MC", "::", "GetELFFlags", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "unsigned", ">", "ElfFlags", "=", "{", "{", "<STR_LIT>", "hexagonv4", "<STR_LIT>", ",", "ELF", "::", "EF_HEXAGON_MACH_V4", "}", ",", "{", "<STR_LIT>", "hexagonv5", "<STR_LIT>", ",", "ELF", "::", "EF_HEXAGON_MACH_V5", "}", ",", "{", "<STR_LIT>", "hexagonv55", "<STR_LIT>", ",", "ELF", "::", "EF_HEXAGON_MACH_V55", "}", ",", "{", "<STR_LIT>", "hexagonv60", "<STR_LIT>", ",", "ELF", "::", "EF_HEXAGON_MACH_V60", "}", ",", "{", "<STR_LIT>", "hexagonv62", "<STR_LIT>", ",", "ELF", "::", "EF_HEXAGON_MACH_V62", "}", ",", "{", "<STR_LIT>", "hexagonv65", "<STR_LIT>", ",", "ELF", "::", "EF_HEXAGON_MACH_V65", "}", ",", "}", ";", "auto", "F", "=", "ElfFlags", ".", "find", "(", "STI", ".", "getCPU", "(", ")", ")", ";", "assert", "(", "F", "!=", "ElfFlags", ".", "end", "(", ")", "&&", "<STR_LIT>", "Unrecognized Architecture", "<STR_LIT>", ")", ";", "return", "F", "->", "second", ";" ]

[ "(", "CC", ")", "&&", "(", "(", "K", "==", "LHS", "&&", "K", "==", "TrueVal", ")", "||", "(", "K", "==", "RHS", "&&", "K", "==", "FalseVal", ")", ")", ")", ";" ]

[ "static", "bool", "isUpperSaturate", "(", "const", "SDValue", "LHS", ",", "const", "SDValue", "RHS", ",", "const", "SDValue", "TrueVal", ",", "const", "SDValue", "FalseVal", ",", "const", "ISD", "::", "CondCode", "CC", ",", "const", "SDValue", "K", ")", "{", "return", "(", "isGTorGE", "(", "CC", ")", "&&", "(", "(", "K", "==", "RHS", "&&", "K", "==", "TrueVal", ")", "||", "(", "K", "==", "LHS", "&&", "K", "==", "FalseVal", ")", ")", ")", "||", "(", "isLTorLE" ]

[ "unsigned", "LanaiInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "(", "match_test", "<STR_LIT>", ")", ")", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")" ]

[ "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]" ]

[ "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI" ]

[ "(", "getImm", "(", ")", ")", ";" ]

[ "void", "addModImmNotOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "CE", "=", "cast", "<", "MCConstantExpr", ">" ]

[ "}" ]

[ "}", "if", "(", "RS", "&&", "FrameReg", "==", "ARM", "::", "SP", "&&", "FrameIndex", "==", "RS", "->", "getScavengingFrameIndex", "(", ")", ")", "{", "assert", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", "&&", "<STR_LIT>", "Cannot use SP to access the emergency spill slot in ", "<STR_LIT>", "<STR_LIT>", "functions without a reserved call frame", "<STR_LIT>", ")", ";", "assert", "(", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "&&", "<STR_LIT>", "Cannot use SP to access the emergency spill slot in ", "<STR_LIT>", "<STR_LIT>", "functions with variable sized frame objects", "<STR_LIT>", ")", ";", "}", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "assert", "(", "AFI", "->", "isThumbFunction", "(", ")", "&&", "<STR_LIT>", "This eliminateFrameIndex only supports Thumb1!", "<STR_LIT>", ")", ";", "if", "(", "rewriteFrameIndex", "(", "MI", ",", "i", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ")", "return", ";", "assert", "(", "Offset", "&&", "<STR_LIT>", "This code isn't needed if offset already handled!", "<STR_LIT>", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "int", "PIdx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "<NUM_LIT>", ")", "removeOperands", "(", "MI", ",", "PIdx", ")", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", ")", "{", "unsigned", "TmpReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "UseRR", "=", "false", ";", "if", "(", "Opcode", "==", "ARM", "::", "tLDRspi", ")", "{", "if", "(", "FrameReg", "==", "ARM", "::", "SP", ")", "emitThumbRegPlusImmInReg", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "false", ",", "TII", ",", "*", "this", ")", ";", "else", "{", "emitLoadConstPool", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "<NUM_LIT>", ",", "Offset", ")", ";", "UseRR", "=", "true", ";", "}", "}", "else", "{", "emitThumbRegPlusImmediate", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "TII", ",", "*", "this", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

[ "def", "rsi", ":", "AsI1", "<", "opcod", ",", "(", "outs", "GPR", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "so_reg_imm", ":", "$", "shift", ")", ",", "DPSoRegImmFrm", ",", "iis", ",", "opc", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR", ":", "$", "Rd", ",", "(", "opnode", "so_reg_imm", ":", "$", "shift", ",", "GPR", ":", "$", "Rn", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteALUsi", ",", "ReadALU", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";" ]

[ "}" ]

[ "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";" ]

[ "xops", "[", "<NUM_LIT>", "]", "=", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "GE", "?", "LEU", ":", "GTU", "," ]

[ "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "{", "rtx", "xops", "[", "<NUM_LIT>", "]", "xops", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "SImode", ")", "emit_insn", "(", "gen_zero_extendqisi2", "(", "xops", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "xops", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "<NUM_LIT>", ")" ]

[ "int", "PPCTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCostInst", "(", "Opcode", ",", "Idx", ",", "Imm", ",", "Ty", ",", "CostKind", ",", "Inst", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "<NUM_LIT>", ")", "return", "~", "<NUM_LIT>", "U", ";", "unsigned", "ImmIdx", "=", "~", "<NUM_LIT>", "U", ";", "bool", "ShiftedFree", "=", "false", ",", "RunFree", "=", "false", ",", "UnsignedFree", "=", "false", ",", "ZeroFree", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "RunFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ShiftedFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "ImmIdx", "=", "<NUM_LIT>", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "UnsignedFree", "=", "true", ";", "ImmIdx", "=", "<NUM_LIT>", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Select", ":", "ZeroFree", "=", "true", ";", "break", ";", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "case", "Instruction", "::", "Store", ":", "break", ";", "}", "if", "(", "ZeroFree", "&&", "Imm", "==", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Idx", "==", "ImmIdx", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "<NUM_LIT>", ")", "{", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "RunFree", ")", "{", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "<NUM_LIT>", "&&", "(", "isShiftedMask_32", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_32", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ST", "->", "isPPC64", "(", ")", "&&", "(", "isShiftedMask_64", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_64", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "if", "(", "UnsignedFree", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ShiftedFree", "&&", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "PPCTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "let", "Switches", "=", "{", "mask", ",", "<NUM_LIT>", "}", ";" ]

[ "class", "SpuInst_MovMask", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc", ",", "string", "asmstr", ">", ":", "ScalarInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "DimMask", ":", "$", "mask", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "mask", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";" ]

[ "}" ]

[ "bool", "XCorePassConfig", "::", "addPreISel", "(", ")", "{", "addPass", "(", "createXCoreLowerThreadLocalPass", "(", ")", ")", ";", "return", "false", ";" ]

[ "return", "NULL_TREE", ";" ]

[ "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "%qE attribute only applies to functions", "<STR_LIT>", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "if", "(", "(", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "<STR_LIT>", "longcall", "<STR_LIT>", ")", "==", "<NUM_LIT>", "&&", "lookup_attribute", "(", "<STR_LIT>", "shortcall", "<STR_LIT>", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "||", "(", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "<STR_LIT>", "shortcall", "<STR_LIT>", ")", "==", "<NUM_LIT>", "&&", "lookup_attribute", "(", "<STR_LIT>", "longcall", "<STR_LIT>", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "cannot apply both %<longcall%> and %<shortcall%> attributes ", "<STR_LIT>", "<STR_LIT>", "to the same function", "<STR_LIT>", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}" ]

[ ")", "return", "true", ";" ]

[ "if", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "Ty", "->", "isFPOrFPVectorTy", "(", ")" ]

[ "void", "i386_pe_seh_init", "(", "FILE", "*", "f", ")", "{", "struct", "seh_frame_state", "*", "seh", ";", "if", "(", "!", "TARGET_SEH", ")", "return", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "gcc_assert", "(", "!", "stack_realign_drap", ")", ";", "seh", "=", "XCNEW", "(", "struct", "seh_frame_state", ")", ";", "cfun", "->", "machine", "->", "seh", "=", "seh", ";", "seh", "->", "sp_offset", "=", "INCOMING_FRAME_SP_OFFSET", ";", "seh", "->", "cfa_offset", "=", "INCOMING_FRAME_SP_OFFSET", ";", "seh", "->", "cfa_reg", "=", "stack_pointer_rtx", ";", "fputs", "(", "<STR_LIT>", "\\t.seh_proc\\t", "<STR_LIT>", ",", "f", ")", ";", "assemble_name", "(", "f", ",", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "cfun", "->", "decl", ")", ")", ")", ";", "fputc", "(", "'", "\\n", "'", ",", "f", ")", ";", "}" ]

[ "Set", "up", "data", "structures", "beginning", "output", "for", "SEH", "." ]

[ ")", ",", "FP64FP16Denormals", "(", "true", ")", "{" ]

[ "IEEE", "(", "true", ")", ",", "DX10Clamp", "(", "true", ")", ",", "FP32Denormals", "(", "true" ]

[ "}" ]

[ "extern", "_", "_", "inline", "long", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "TM_is_failure_persistent", "(", "void", "*", "const", "TM_buff", ")", "{", "texasru_t", "texasru", "=", "*", "_", "TEXASRU_PTR", "(", "TM_buff", ")", ";", "return", "_", "TEXASRU_FAILURE_PERSISTENT", "(", "texasru", ")", ";" ]

[ "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SDValue", "R", "=", "PerformParabixDAGCombine", "(", "N", ",", "DCI", ")", ";", "if", "(", "R", ".", "getNode", "(", ")", ")", "return", "R", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "VSELECT", ":", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformAddCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSubCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformADCCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformAndCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "PerformLOADCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "PerformSINT_TO_FPCombine", "(", "N", ",", "DAG", ",", "this", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "PerformFADDCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "PerformFSUBCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFMinFMaxCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFANDNCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "PerformSExtCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "PerformSIGN_EXTEND_INREGCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "PerformTruncateCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "PerformISDSETCCCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBrCondCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performVZEXTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FMA", ":", "return", "PerformFMACombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformINTRINSIC_WO_CHAINCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformINSERTPSCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "CommentStream", ")", "HasCustomInstComment", "=", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "if", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "OS", "<<", "<STR_LIT>", "\\tlock\\t", "<STR_LIT>", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode64Bit", "]", ")", ")", "{", "OS", "<<", "<STR_LIT>", "\\tcallq\\t", "<STR_LIT>", ";", "printPCRelImm", "(", "MI", ",", "<NUM_LIT>", ",", "OS", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", ")", "{", "MCInst", "Data32MI", "(", "*", "MI", ")", ";", "Data32MI", ".", "setOpcode", "(", "X86", "::", "DATA32_PREFIX", ")", ";", "printInstruction", "(", "&", "Data32MI", ",", "OS", ")", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "ashiftrt", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "UNSPEC_REAL_MULT", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "Sched", "[", "WriteVecInsert", "]", ">", ";", "<FIXE>" ]

[ "<STR_LIT>", ")", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "X86pinsrw", "VR128", ":", "$", "src1", ",", "GR32orGR64", ":", "$", "src2", ",", "imm", ":", "$", "src3", ")", ")", "]", ">", ",", "<BUGS>", "Sched", "[", "WriteShuffle", "]", ">", ";", "<BUGE>", "def", "rm", ":", "Ii8", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "VR128", ":", "$", "src1", ",", "i16mem", ":", "$", "src2", ",", "u8imm", ":", "$", "src3", ")", "," ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "_", "v4sf", ")", "_", "mm_avx512_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_getmant_ps", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A", ",", "_", "MM_MANTISSA_NORM_ENUM", "_", "_", "B", ",", "_", "MM_MANTISSA_SIGN_ENUM", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_getmantps128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "C", "<<", "<NUM_LIT>", ")", "|", "_", "_", "B", ",", "(", "_" ]

[ "ResultReg", ")", ";" ]

[ "bool", "AArch64FastISel", "::", "selectBitCast", "(", "const", "Instruction", "*", "I", ")", "{", "MVT", "RetVT", ",", "SrcVT", ";", "if", "(", "!", "isTypeLegal", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ",", "SrcVT", ")", ")", "return", "false", ";", "if", "(", "!", "isTypeLegal", "(", "I", "->", "getType", "(", ")", ",", "RetVT", ")", ")", "return", "false", ";", "unsigned", "Opc", ";", "if", "(", "RetVT", "==", "MVT", "::", "f32", "&&", "SrcVT", "==", "MVT", "::", "i32", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "RetVT", "==", "MVT", "::", "f64", "&&", "SrcVT", "==", "MVT", "::", "i64", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "RetVT", "==", "MVT", "::", "i32", "&&", "SrcVT", "==", "MVT", "::", "f32", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "RetVT", "==", "MVT", "::", "i64", "&&", "SrcVT", "==", "MVT", "::", "f64", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "return", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "switch", "(", "RetVT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected value type.", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "i64", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "f32", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "f64", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "unsigned", "Op0Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "Op0Reg", ")", "return", "false", ";", "unsigned", "ResultReg", "=", "fastEmitInst_r", "(", "Opc", ",", "RC", ",", "Op0Reg", ")", ";", "if", "(", "!", "ResultReg", ")", "return", "false", ";", "updateValueMap", "(", "I", "," ]

[ "artificial__", ")", ")", "_", "mm512_sqrt_ph", "(", "_", "_", "m512h", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_" ]

[ "<FIXS>", "for", "(", "MVT", "VT", ":", "MVT", "::", "fixedlen_vector_valuetypes", "(", ")", ")", "{", "<FIXE>" ]

[ "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "{", "<BUGS>", "for", "(", "MVT", "VT", ":", "MVT", "::", "vector_valuetypes", "(", ")", ")", "{", "<BUGE>", "setOperationAction", "(", "ISD", "::", "ADD", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "VT", ",", "Legal", ")", ";" ]

[ ")" ]

[ "[", "(", "set", "(", "pc", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ ";" ]

[ "def", "A2_vsububs", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>" ]

[ "if", "(", "Result", "!=", "Symbols", "->", "end", "(", ")", ")", "{" ]

[ "auto", "Result", "=", "std", "::", "find_if", "(", "Symbols", "->", "begin", "(", ")", ",", "Symbols", "->", "end", "(", ")", ",", "[", "Value", "]", "(", "const", "SymbolInfoTy", "&", "Val", ")", "{", "return", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "Val", ")", "==", "static_cast", "<", "uint64_t", ">", "(", "Value", ")", "&&", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "Val", ")", "==", "ELF", "::", "STT_NOTYPE", ";", "}", ")", ";" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}" ]

[ "}" ]

[ "_", "_", "arm_vstrhq_scatter_offset", "(", "float16_t", "*", "_", "_", "base", ",", "uint16x8_t", "_", "_", "offset", ",", "float16x8_t", "_", "_", "value", ")", "{", "_", "_", "arm_vstrhq_scatter_offset_f16", "(", "_", "_", "base", ",", "_", "_", "offset", ",", "_", "_", "value", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src1", ";", "let", "SrcExtra", "=", "src2", ";", "let", "Dest", "=", "dest", ";", "let", "Switches", "=", "sw", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";" ]

[ "&&", "<STR_LIT>", "Slot for FPW register must be last in order to be found!", "<STR_LIT>", ")", ";" ]

[ "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")" ]

[ "]", ")" ]

[ "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", "{", "<FIXE>" ]

[ "def", "BFMwwii", ":", "A64I_bitfield", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "GPR32", ":", "$", "Rd", ")", ",", "(", "ins", "GPR32", ":", "$", "src", ",", "GPR32", ":", "$", "Rn", ",", "bitfield32_imm", ":", "$", "ImmR", ",", "bitfield32_imm", ":", "$", "ImmS", ")", ",", "<BUGS>", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", "{", "<BUGE>", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "}" ]

[ "}" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "A2_tfrsi", ")", "{", "auto", "Op", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_GlobalAddress", ")", "return", "false", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "return", "false", ";", "}" ]

[ "<STR_LIT>", ";" ]

[ "const", "char", "*", "output_movb", "(", "rtx", "*", "operands", ",", "rtx", "insn", ",", "int", "which_alternative", ",", "int", "reverse_comparison", ")", "{", "if", "(", "next_real_insn", "(", "JUMP_LABEL", "(", "insn", ")", ")", "==", "next_real_insn", "(", "insn", ")", ")", "{", "if", "(", "which_alternative", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "copy %1,%0", "<STR_LIT>", ";", "else", "if", "(", "which_alternative", "==", "<NUM_LIT>", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "stw %1,-16(%%r30)", "<STR_LIT>", ",", "operands", ")", ";", "return", "<STR_LIT>", "{fldws|fldw} -16(%%r30),%0", "<STR_LIT>", ";", "}", "else", "if", "(", "which_alternative", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "stw %1,%0", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "mtsar %r1", "<STR_LIT>", ";", "}", "if", "(", "reverse_comparison", ")", "PUT_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ",", "reverse_condition", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", ";", "if", "(", "which_alternative", "==", "<NUM_LIT>", ")", "{", "int", "nullify", "=", "INSN_ANNULLED_BRANCH_P", "(", "insn", ")", ";", "int", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", "==", "<NUM_LIT>", "&&", "dbr_sequence_length", "(", ")", "==", "<NUM_LIT>", ")", "nullify", "=", "<NUM_LIT>", ";", "if", "(", "!", "nullify", "&&", "length", "==", "<NUM_LIT>", "&&", "dbr_sequence_length", "(", ")", "==", "<NUM_LIT>", ")", "nullify", "=", "forward_branch_p", "(", "insn", ")", ";", "switch", "(", "length", ")", "{", "case", "<NUM_LIT>", ":", "if", "(", "nullify", ")", "return", "<STR_LIT>", "movb,%C2,n %1,%0,%3", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "movb,%C2 %1,%0,%3" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>" ]

[ ")", ":", "true", ")", ";" ]

[ "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "from", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "?", "!", "TARGET_MINIMAL_TOC", "||", "TARGET_NO_TOC_OR_PCREL", "||", "constant_pool_empty_p", "(" ]

[ "c", ")", ";" ]

[ "vsra_n_s8", "(", "int8x8_t", "_", "_", "a", ",", "int8x8_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "int8x8_t", ")", "_", "_", "builtin_aarch64_ssra_nv8qi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_" ]

[ "(", "const_int", "<NUM_LIT>", ")" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "cond", "[", "(", "lt", "(", "abs", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", "(", "pc", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "const_int", "MAX_12BIT_OFFSET", ")", ")" ]

[ "if", "(", "opts", "->", "x_flag_align_jumps", "&&", "!", "opts", "->", "x_str_align_jumps", ")", "opts", "->", "x_str_align_jumps", "=", "processor_cost_table", "[", "ix86_tune", "]", "->", "align_jump", ";" ]

[ "static", "void", "ix86_default_align", "(", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "opts", "->", "x_flag_align_loops", "&&", "!", "opts", "->", "x_str_align_loops", ")", "opts", "->", "x_str_align_loops", "=", "processor_cost_table", "[", "ix86_tune", "]", "->", "align_loop", ";" ]

[ ")", "]" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V", "[", "(", "match_operand", ":", "<", "non_vec", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_VEC_SET", ")" ]

[ "static", "bool", "expand_vec_perm_vpermt2_vpshub2", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "if", "(", "!", "TARGET_AVX512BW", "||", "!", "(", "d", "->", "vmode", "==", "V64QImode", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "struct", "expand_vec_perm_d", "ds", "[", "<NUM_LIT>", "]", ";", "rtx", "rperm", "[", "<NUM_LIT>", "]", ",", "vperm", ",", "target0", ",", "target1", ";", "unsigned", "int", "i", ",", "nelt", ";", "machine_mode", "vmode", ";", "nelt", "=", "d", "->", "nelt", ";", "vmode", "=", "V64QImode", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "ds", "[", "i", "]", "=", "*", "d", ";", "ds", "[", "i", "]", ".", "vmode", "=", "V32HImode", ";", "ds", "[", "i", "]", ".", "nelt", "=", "<NUM_LIT>", ";", "ds", "[", "i", "]", ".", "target", "=", "gen_reg_rtx", "(", "V32HImode", ")", ";", "ds", "[", "i", "]", ".", "op0", "=", "gen_lowpart", "(", "V32HImode", ",", "d", "->", "op0", ")", ";", "ds", "[", "i", "]", ".", "op1", "=", "gen_lowpart", "(", "V32HImode", ",", "d", "->", "op1", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "ds", "[", "i", "&", "<NUM_LIT>", "]", ".", "perm", "[", "i", "/", "<NUM_LIT>", "]", "=", "d", "->", "perm", "[", "i", "]", "/", "<NUM_LIT>", ";", "if", "(", "i", "&", "<NUM_LIT>", ")", "{", "rperm", "[", "i", "]", "=", "constm1_rtx", ";", "rperm", "[", "i", "+", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "(", "i", "&", "<NUM_LIT>", ")", "+", "(", "d", "->", "perm", "[", "i", "]", "&", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "rperm", "[", "i", "]", "=", "GEN_INT", "(", "(", "i", "&", "<NUM_LIT>", ")", "+", "(", "d", "->", "perm", "[", "i", "]", "&", "<NUM_LIT>", ")", ")", ";", "rperm", "[", "i", "+", "<NUM_LIT>", "]", "=", "constm1_rtx", ";", "}", "}", "bool", "ok", "=", "expand_vec_perm_1", "(", "&", "ds", "[", "<NUM_LIT>", "]", ")", ";", "gcc_assert", "(", "ok", ")", ";", "ds", "[", "<NUM_LIT>", "]", ".", "target", "=", "gen_lowpart", "(", "V64QImode", ",", "ds", "[", "<NUM_LIT>", "]", ".", "target", ")", ";", "ok", "=", "expand_vec_perm_1", "(", "&", "ds", "[", "<NUM_LIT>", "]", ")", ";", "gcc_assert", "(", "ok", ")", ";", "ds", "[", "<NUM_LIT>", "]", ".", "target", "=", "gen_lowpart", "(", "V64QImode", ",", "ds", "[", "<NUM_LIT>", "]", ".", "target", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V64QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "rperm", ")", ")", ";", "vperm", "=", "force_reg", "(", "vmode", ",", "vperm", ")", ";", "target0", "=", "gen_reg_rtx", "(", "V64QImode", ")", ";", "emit_insn", "(", "gen_avx512bw_pshufbv64qi3", "(", "target0", ",", "ds", "[", "<NUM_LIT>", "]", ".", "target", ",", "vperm", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V64QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "rperm", "+", "<NUM_LIT>", ")", ")", ";", "vperm", "=", "force_reg", "(", "vmode", ",", "vperm", ")", ";", "target1", "=", "gen_reg_rtx", "(", "V64QImode", ")", ";", "emit_insn", "(", "gen_avx512bw_pshufbv64qi3", "(", "target1", ",", "ds", "[", "<NUM_LIT>", "]", ".", "target", ",", "vperm", ")", ")", ";", "emit_insn", "(", "gen_iorv64qi3", "(", "d", "->", "target", ",", "target0", ",", "target1", ")", ")", ";", "return", "true", ";", "}" ]

[ "Implement", "arbitrary", "permutations", "of", "two", "V64QImode", "operands", "with", "2", "vperm", "[", "it", "]", "2w", ",", "2", "vpshufb", "and", "one", "vpor", "instruction", "." ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "_", "m128h", "_", "_", "D", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_div_ph", "(", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ",", "_" ]

[ "<STR_LIT>", ">", ";" ]

[ "def", "HasDES", ":", "Predicate", "<", "<STR_LIT>", ">", ",", "AssemblerPredicate", "<" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>" ]

[ "}" ]

[ "class", "addsub_shifted_imm", "<", "ValueType", "Ty", ">", ":", "Operand", "<", "Ty", ">", ",", "ComplexPattern", "<", "Ty", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "imm", "]", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "i32imm", ",", "addsub_shift", ")", ";" ]

[ "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ByValVA", ".", "getLocReg", "(", ")", ",", "ResidueVal", ")", ")", ";" ]

[ "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "const", "SDValue", "StackPtr", "=", "IsPPC64", "?", "DAG", ".", "getRegister", "(", "PPC", "::", "X1", ",", "MVT", "::", "i64", ")", ":", "DAG", ".", "getRegister", "(", "PPC", "::", "R1", ",", "MVT", "::", "i32", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "ArgLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "const", "unsigned", "ValNo", "=", "ArgLocs", "[", "I", "]", ".", "getValNo", "(", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "ValNo", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "ValNo", "]", ".", "Flags", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "const", "unsigned", "ByValSize", "=", "Flags", ".", "getByValSize", "(", ")", ";", "if", "(", "!", "ByValSize", ")", "{", "++", "I", ";", "continue", ";", "}", "auto", "GetLoad", "=", "[", "&", "]", "(", "EVT", "VT", ",", "unsigned", "LoadOffset", ")", "{", "return", "DAG", ".", "getExtLoad", "(", "ISD", "::", "ZEXTLOAD", ",", "dl", ",", "PtrVT", ",", "Chain", ",", "(", "LoadOffset", "!=", "<NUM_LIT>", ")", "?", "DAG", ".", "getObjectPtrOffset", "(", "dl", ",", "Arg", ",", "TypeSize", "::", "Fixed", "(", "LoadOffset", ")", ")", ":", "Arg", ",", "MachinePointerInfo", "(", ")", ",", "VT", ")", ";", "}", ";", "unsigned", "LoadOffset", "=", "<NUM_LIT>", ";", "while", "(", "LoadOffset", "+", "PtrByteSize", "<=", "ByValSize", "&&", "ArgLocs", "[", "I", "]", ".", "isRegLoc", "(", ")", ")", "{", "SDValue", "Load", "=", "GetLoad", "(", "PtrVT", ",", "LoadOffset", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "LoadOffset", "+=", "PtrByteSize", ";", "const", "CCValAssign", "&", "ByValVA", "=", "ArgLocs", "[", "I", "++", "]", ";", "assert", "(", "ByValVA", ".", "getValNo", "(", ")", "==", "ValNo", "&&", "<STR_LIT>", "Unexpected location for pass-by-value argument.", "<STR_LIT>", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ByValVA", ".", "getLocReg", "(", ")", ",", "Load", ")", ")", ";", "}", "if", "(", "LoadOffset", "==", "ByValSize", ")", "continue", ";", "assert", "(", "ArgLocs", "[", "I", "]", ".", "getValNo", "(", ")", "==", "ValNo", "&&", "<STR_LIT>", "Expected additional location for by-value argument.", "<STR_LIT>", ")", ";", "if", "(", "ArgLocs", "[", "I", "]", ".", "isMemLoc", "(", ")", ")", "{", "assert", "(", "LoadOffset", "<", "ByValSize", "&&", "<STR_LIT>", "Unexpected memloc for by-val arg.", "<STR_LIT>", ")", ";", "const", "CCValAssign", "&", "ByValVA", "=", "ArgLocs", "[", "I", "++", "]", ";", "ISD", "::", "ArgFlagsTy", "MemcpyFlags", "=", "Flags", ";", "MemcpyFlags", ".", "setByValSize", "(", "ByValSize", "-", "LoadOffset", ")", ";", "Chain", "=", "CallSeqStart", "=", "createMemcpyOutsideCallSeq", "(", "(", "LoadOffset", "!=", "<NUM_LIT>", ")", "?", "DAG", ".", "getObjectPtrOffset", "(", "dl", ",", "Arg", ",", "TypeSize", "::", "Fixed", "(", "LoadOffset", ")", ")", ":", "Arg", ",", "DAG", ".", "getObjectPtrOffset", "(", "dl", ",", "StackPtr", ",", "TypeSize", "::", "Fixed", "(", "ByValVA", ".", "getLocMemOffset", "(", ")", ")", ")", ",", "CallSeqStart", ",", "MemcpyFlags", ",", "DAG", ",", "dl", ")", ";", "continue", ";", "}", "const", "unsigned", "ResidueBytes", "=", "ByValSize", "%", "PtrByteSize", ";", "assert", "(", "ResidueBytes", "!=", "<NUM_LIT>", "&&", "LoadOffset", "+", "PtrByteSize", ">", "ByValSize", "&&", "<STR_LIT>", "Unexpected register residue for by-value argument.", "<STR_LIT>", ")", ";", "SDValue", "ResidueVal", ";", "for", "(", "unsigned", "Bytes", "=", "<NUM_LIT>", ";", "Bytes", "!=", "ResidueBytes", ";", ")", "{", "const", "unsigned", "N", "=", "PowerOf2Floor", "(", "ResidueBytes", "-", "Bytes", ")", ";", "const", "MVT", "VT", "=", "N", "==", "<NUM_LIT>", "?", "MVT", "::", "i8", ":", "(", "(", "N", "==", "<NUM_LIT>", ")", "?", "MVT", "::", "i16", ":", "(", "N", "==", "<NUM_LIT>", "?", "MVT", "::", "i32", ":", "MVT", "::", "i64", ")", ")", ";", "SDValue", "Load", "=", "GetLoad", "(", "VT", ",", "LoadOffset", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "LoadOffset", "+=", "N", ";", "Bytes", "+=", "N", ";", "assert", "(", "PtrVT", ".", "getSimpleVT", "(", ")", ".", "getSizeInBits", "(", ")", ">", "(", "Bytes", "*", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Unexpected load emitted during handling of pass-by-value ", "<STR_LIT>", "<STR_LIT>", "argument.", "<STR_LIT>", ")", ";", "unsigned", "NumSHLBits", "=", "PtrVT", ".", "getSimpleVT", "(", ")", ".", "getSizeInBits", "(", ")", "-", "(", "Bytes", "*", "<NUM_LIT>", ")", ";", "EVT", "ShiftAmountTy", "=", "getShiftAmountTy", "(", "Load", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "SHLAmt", "=", "DAG", ".", "getConstant", "(", "NumSHLBits", ",", "dl", ",", "ShiftAmountTy", ")", ";", "SDValue", "ShiftedLoad", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "Load", ".", "getValueType", "(", ")", ",", "Load", ",", "SHLAmt", ")", ";", "ResidueVal", "=", "ResidueVal", "?", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "PtrVT", ",", "ResidueVal", ",", "ShiftedLoad", ")", ":", "ShiftedLoad", ";", "}", "const", "CCValAssign", "&", "ByValVA", "=", "ArgLocs", "[", "I", "++", "]", ";" ]

[ ")", ";" ]

[ "const", "LegalizerInfo", "*", "getLegalizerInfo", "(", ")", "const", "override", "{", "return", "Legalizer", ".", "get", "(" ]

[ "KryoUnitX", "]", ">", "{" ]

[ "def", "KryoWrite_5cyc_X_71ln", ":", "SchedWriteRes", "<", "[" ]

[ "if", "(", "!", "Op", "||", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RParen", ")", ")", "{" ]

[ "if", "(", "!", "Op", ")", "{", "Op", "=", "ParseImmediate", "(", ")", ";", "if", "(", "Op", ")", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "Op2", "=", "Op", ";", "Op", "=", "ParseRegister", "(", "RegNo", ")", ";" ]

[ "}" ]

[ "IntrinsicID", "=", "getIntrinsicForGCCBuiltin", "(", "<STR_LIT>", "AMDGPU", "<STR_LIT>", ",", "Name", ")", ";", "if", "(", "IntrinsicID", "!=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Intrinsic", "::", "not", "_", "intrinsic", ")", "{", "return", "IntrinsicID", ";" ]

[ ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "Visited", ".", "insert", "(", "Base", ")", ";" ]

[ "int", "BaseOp", "=", "getBaseOperandIndex", "(", "MI", ")", ";", "if", "(", "BaseOp", "==", "-", "<NUM_LIT>", "||", "!", "MI", ".", "getOperand", "(", "BaseOp", ")", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "Base", "=", "MI", ".", "getOperand", "(", "BaseOp", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "Base", ".", "isVirtual", "(", ")", "||", "Visited", ".", "count", "(", "Base", ")", ")", "continue", ";" ]

[ "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rmode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dst", ";", "let", "SrcA", "=", "src", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_pfcmpge", "(", "_", "_", "m64", "_", "_", "A", ",", "_", "_", "m64", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_pfcmpge", "(", "(", "_", "_", "v2sf", ")", "_", "_", "A", ",", "(", "_", "_", "v2sf", ")", "_", "_", "B", ")", ";" ]

[ "}" ]

[ "vzipq_s32", "(", "int32x4_t", "_", "_", "a", ",", "int32x4_t", "_", "_", "b", ")", "{", "int32x4x2_t", "_", "_", "rv", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint32x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint32x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint32x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint32x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "return", "_", "_", "rv", ";" ]

[ "<FIXS>", "machine_mode", "op0mode", "=", "GET_MODE", "(", "op0", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "<FIXE>" ]

[ "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "<BUGS>", "enum", "machine_mode", "op0mode", "=", "GET_MODE", "(", "op0", ")", ";", "enum", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "enum", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "<BUGE>", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode" ]

[ "return", "cpOut", ";" ]

[ "}", "SDValue", "cpIn", "=", "DAG", ".", "getCopyToReg", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DL", ",", "Reg", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "SDValue", "(", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "cpIn", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getTargetConstant", "(", "size", ",", "MVT", "::", "i8", ")", ",", "cpIn", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "MachineMemOperand", "*", "MMO", "=", "cast", "<", "AtomicSDNode", ">", "(", "Op", ")", "->", "getMemOperand", "(", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Tys", ",", "Ops", ",", "<NUM_LIT>", ",", "T", ",", "MMO", ")", ";", "SDValue", "cpOut", "=", "DAG", ".", "getCopyFromReg", "(", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "Reg", ",", "T", ",", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "_", "b", ")", "{" ]

[ "vqsub_s64", "(", "int64x1_t", "_", "_", "a", ",", "int64x1_t", "_" ]

[ ")", "return", "Input", ";" ]

[ "unsigned", "Opc", "=", "Input", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ISD", "::", "TRUNCATE", "&&", "(", "Input", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AssertSext", "||", "Input", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", ")", ")", "return", "Input", ";", "LoadSDNode", "*", "InputLoad", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "Input", ")", ";", "if", "(", "InputLoad", "&&", "InputLoad", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD" ]

[ "$", "Vn", ")", ",", "(", "OpTy", "(", "NEONvduplane", "(", "OpTy", "DPR_8", ":", "$", "Vm", ")", ",", "imm", ":", "$", "lane", ")", ")", ")", ")", ")", "]", ">", ";" ]

[ "class", "N3VLInt3SL16", "<", "bit", "op24", ",", "bits", "<", "<NUM_LIT>", ">", "op21_20", ",", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "InstrItinClass", "itin", ",", "string", "OpcodeStr", ",", "string", "Dt", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "SDPatternOperator", "IntOp", ">", ":", "N3VLane16", "<", "op24", ",", "<NUM_LIT>", ",", "op21_20", ",", "op11_8", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "QPR", ":", "$", "src1", ",", "DPR", ":", "$", "Vn", ",", "DPR_8", ":", "$", "Vm", ",", "VectorIndex16", ":", "$", "lane", ")", ",", "NVMulSLFrm", ",", "itin", ",", "OpcodeStr", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "ResTy", "QPR", ":", "$", "Vd", ")", ",", "(", "ResTy", "(", "IntOp", "(", "ResTy", "QPR", ":", "$", "src1", ")", ",", "(", "OpTy", "DPR", ":" ]

[ "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";" ]

[ "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "!", "IN_RANGE", "(", "TREE_INT_CST_LOW", "(", "arg1", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be a 1-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_altivec_vspltw", ")", "{", "STRIP_NOPS", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "TREE_INT_CST_LOW", "(", "arg1", ")", "&", "~", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be a 2-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_vgnb", ")", "{", "STRIP_NOPS", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "(", "TREE_INT_CST_LOW", "(", "arg1", ")", "&", "~", "<NUM_LIT>", ")", "||", "!", "IN_RANGE", "(", "TREE_INT_CST_LOW", "(", "arg1", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be unsigned literal between ", "<STR_LIT>", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_altivec_vsplth", ")", "{", "STRIP_NOPS", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "TREE_INT_CST_LOW", "(", "arg1", ")", "&", "~", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be a 3-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_altivec_vspltb", ")", "{", "STRIP_NOPS", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "TREE_INT_CST_LOW", "(", "arg1", ")", "&", "~", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be a 4-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_altivec_vcfux", "||", "icode", "==", "CODE_FOR_altivec_vcfsx", "||", "icode", "==", "CODE_FOR_altivec_vctsxs", "||", "icode", "==", "CODE_FOR_altivec_vctuxs", "||", "icode", "==", "CODE_FOR_vsx_xvcvuxddp_scale", "||", "icode", "==", "CODE_FOR_vsx_xvcvsxddp_scale", ")", "{", "STRIP_NOPS", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "TREE_INT_CST_LOW", "(", "arg1", ")", "&", "~", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be a 5-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_dfptstsfi_eq_dd", "||", "icode", "==", "CODE_FOR_dfptstsfi_lt_dd", "||", "icode", "==", "CODE_FOR_dfptstsfi_gt_dd", "||", "icode", "==", "CODE_FOR_dfptstsfi_unordered_dd", "||", "icode", "==", "CODE_FOR_dfptstsfi_eq_td", "||", "icode", "==", "CODE_FOR_dfptstsfi_lt_td", "||", "icode", "==", "CODE_FOR_dfptstsfi_gt_td", "||", "icode", "==", "CODE_FOR_dfptstsfi_unordered_td", ")", "{", "STRIP_NOPS", "(", "arg0", ")", ";", "if", "(", "TREE_CODE", "(", "arg0", ")", "!=", "INTEGER_CST", "||", "!", "IN_RANGE", "(", "TREE_INT_CST_LOW", "(", "arg0", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "error", "(", "<STR_LIT>", "argument 1 must be a 6-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "else", "if", "(", "icode", "==", "CODE_FOR_xststdcqp_kf", "||", "icode", "==", "CODE_FOR_xststdcqp_tf", "||", "icode", "==", "CODE_FOR_xststdcdp", "||", "icode", "==", "CODE_FOR_xststdcsp", "||", "icode", "==", "CODE_FOR_xvtstdcdp", "||", "icode", "==", "CODE_FOR_xvtstdcsp", ")", "{", "STRIP_NOPS", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "!=", "INTEGER_CST", "||", "!", "IN_RANGE", "(", "TREE_INT_CST_LOW", "(", "arg1", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "error", "(", "<STR_LIT>", "argument 2 must be a 7-bit unsigned literal", "<STR_LIT>", ")", ";", "return", "CONST0_RTX", "(", "tmode", ")", ";", "}", "}", "if", "(", "target", "==", "<NUM_LIT>", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";" ]

[ ",", "SetCC", ")", ";" ]

[ "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "DL", ",", "N", "->", "getVTList", "(", ")", ",", "Sum", ",", "SetCC", ")", ";", "}", "}", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Sum", "=", "DAG", ".", "getNode", "(", "BaseOp", ",", "DL", ",", "VTs", ",", "LHS", ",", "RHS", ")", ";", "SDValue", "SetCC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i8", ",", "DAG", ".", "getConstant", "(", "Cond", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "SDValue", "(", "Sum", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i1", ")", "{", "SetCC", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "MVT", "::", "i8", ",", "SetCC", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i1", ")", ")", ";", "SetCC", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i1", ",", "SetCC", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "DL", ",", "N", "->", "getVTList", "(", ")", ",", "Sum" ]