Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ".", "CPEMI", "==", "CPEMI", ")", "return", "&", "CPE", ";" ]

[ "ARMConstantIslands", "::", "CPEntry", "*", "ARMConstantIslands", "::", "findConstPoolEntry", "(", "unsigned", "CPI", ",", "const", "MachineInstr", "*", "CPEMI", ")", "{", "std", "::", "vector", "<", "CPEntry", ">", "&", "CPEs", "=", "CPEntries", "[", "CPI", "]", ";", "for", "(", "CPEntry", "&", "CPE", ":", "CPEs", ")", "if", "(", "CPE" ]

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

[ "def", "L2_loadruh_io", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s31_1Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_17e0d2cd", ",", "TypeLD", ">", ",", "Enc_de0214", ",", "AddrModeRel", ",", "PostInc_BaseImm", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

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

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

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "BI", "(", "not", ":", "BI", "(", "match_operator", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

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

[ "let", "CextOpcode", "=", "<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", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "DCI", ".", "AddToWorklist", "(", "Cast", ".", "getNode", "(", ")", ")", ";" ]

[ "}", "if", "(", "Vec", ".", "hasOneUse", "(", ")", "&&", "DCI", ".", "isBeforeLegalize", "(", ")", ")", "{", "SDLoc", "SL", "(", "N", ")", ";", "EVT", "EltVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "Idx", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Opc", "=", "Vec", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "UMIN", ":", "case", "ISD", "::", "UMAX", ":", "case", "ISD", "::", "SMIN", ":", "case", "ISD", "::", "SMAX", ":", "case", "ISD", "::", "FMAXNUM", ":", "case", "ISD", "::", "FMINNUM", ":", "return", "DAG", ".", "getNode", "(", "Opc", ",", "SL", ",", "EltVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "SL", ",", "EltVT", ",", "Vec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Idx", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "SL", ",", "EltVT", ",", "Vec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Idx", ")", ")", ";", "}", "}", "if", "(", "!", "DCI", ".", "isBeforeLegalize", "(", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "VecSize", "=", "VecVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "EltSize", "=", "EltVT", ".", "getSizeInBits", "(", ")", ";", "auto", "*", "Idx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "EltSize", "<=", "<NUM_LIT>", "&&", "EltVT", ".", "isByteSized", "(", ")", "&&", "VecSize", ">", "<NUM_LIT>", "&&", "VecSize", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "Idx", ")", "{", "EVT", "NewVT", "=", "getEquivalentMemType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VecVT", ")", ";", "unsigned", "BitIndex", "=", "Idx", "->", "getZExtValue", "(", ")", "*", "EltSize", ";", "unsigned", "EltIdx", "=", "BitIndex", "/", "<NUM_LIT>", ";", "unsigned", "LeftoverBitIdx", "=", "BitIndex", "%", "<NUM_LIT>", ";", "SDLoc", "SL", "(", "N", ")", ";", "SDValue", "Cast", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "NewVT", ",", "Vec", ")", ";" ]

[ "TSInfo", ";" ]

[ "virtual", "const", "TeeRISCSelectionDAGInfo", "*", "getSelectionDAGInfo", "(", ")", "const", "{", "return", "&" ]

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

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable" ]

[ "<FIXS>", "if", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "<FIXE>", "<FIXS>", "else", "if", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "<FIXE>" ]

[ "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "<BUGS>", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "REG", "<BUGE>", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "!=", "<NUM_LIT>", ")", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "<BUGS>", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "REG", "<BUGE>", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "!=", "<NUM_LIT>", ")", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")" ]

[ "(", "MO1", ")", ";" ]

[ "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "opCode", ")", ";", "TmpInst", ".", "addOperand", "(", "Rdd", ")", ";", "TmpInst", ".", "addOperand" ]

[ ",", "lastInstr", ")", ";" ]

[ "if", "(", "!", "validateCandidates", "(", "SourceRegion", ",", "TargetRegion", ")", ")", "return", "false", ";", "moveAndUpdatePHIs", "(", "SourceRegion", ".", "BranchBlock", ",", "SourceRegion", ".", "BranchTargetBlock", ")", ";", "MachineBasicBlock", "::", "iterator", "firstInstr", "=", "SourceRegion", ".", "BranchBlock", "->", "getFirstNonPHI", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "lastInstr", "=", "SourceRegion", ".", "BranchBlock", "->", "getFirstTerminator", "(", ")", ";", "MachineBasicBlock", "*", "Source", "=", "SourceRegion", ".", "MustMoveDown", "?", "SourceRegion", ".", "BranchTargetBlock", ":", "TargetRegion", ".", "BranchBlock", ";", "MachineBasicBlock", "::", "iterator", "Target", "=", "SourceRegion", ".", "MustMoveDown", "?", "SourceRegion", ".", "BranchTargetBlock", "->", "getFirstNonPHI", "(", ")", ":", "TargetRegion", ".", "BranchBlock", "->", "getFirstTerminator", "(", ")", ";", "Source", "->", "splice", "(", "Target", ",", "SourceRegion", ".", "BranchBlock", ",", "firstInstr" ]

[ "size", ";" ]

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

[ "<FIXS>", "if", "(", "TARGET_POWER10", "&&", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_PREFIXED", ")", "==", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "else", "if", "(", "TARGET_PREFIXED", "&&", "!", "TARGET_POWER10", ")", "<FIXE>", "<FIXS>", "error", "(", "<STR_LIT>", "%qs requires %qs", "<STR_LIT>", ",", "<STR_LIT>", "-mprefixed", "<STR_LIT>", ",", "<STR_LIT>", "-mcpu=power10", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "rs6000_isa_flags", "&=", "~", "OPTION_MASK_FLOAT128_HW", ";", "}", "<BUGS>", "if", "(", "TARGET_FUTURE", "&&", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_PREFIXED", ")", "==", "<NUM_LIT>", ")", "<BUGE>", "rs6000_isa_flags", "|=", "OPTION_MASK_PREFIXED", ";", "<BUGS>", "else", "if", "(", "TARGET_PREFIXED", "&&", "!", "TARGET_FUTURE", ")", "<BUGE>", "{", "if", "(", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_PREFIXED", ")", "!=", "<NUM_LIT>", ")", "<BUGS>", "error", "(", "<STR_LIT>", "%qs requires %qs", "<STR_LIT>", ",", "<STR_LIT>", "-mprefixed", "<STR_LIT>", ",", "<STR_LIT>", "-mcpu=future", "<STR_LIT>", ")", ";", "<BUGE>", "rs6000_isa_flags", "&=", "~", "OPTION_MASK_PREFIXED", ";", "}" ]

[ ";" ]

[ "Offset", "=", "CurDAG", "->", "getTargetConstant", "(", "IMMOffset", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Addr", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true", ";", "}", "if", "(", "(", "IMMOffset", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Addr", ")", ")", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "IMMOffset", "->", "getZExtValue", "(", ")", ")", ")", "{", "Base", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "CurDAG", "->", "getEntryNode", "(", ")", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "Offset", "=", "CurDAG", "->", "getTargetConstant", "(", "IMMOffset", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Addr", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true" ]

[ "}" ]

[ "platform", "=", "elf_platform", "(", ")", ";", "if", "(", "platform", "!=", "NULL", ")", "return", "platform", ";", "else", "return", "<STR_LIT>", "powerpc", "<STR_LIT>", ";" ]

[ "MVEDomain", ";" ]

[ "class", "MVE_VMOV_lane_base", "<", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "asm", ",", "string", "suffix", ",", "string", "ops", ",", "string", "cstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "Thumb2I", "<", "oops", ",", "iops", ",", "AddrModeNone", ",", "<NUM_LIT>", ",", "itin", ",", "asm", ",", "!", "if", "(", "!", "eq", "(", "suffix", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "<STR_LIT>", "#", "suffix", ")", "#", "<STR_LIT>", "#", "ops", ",", "cstr", ",", "pattern", ">", ",", "Requires", "<", "[", "HasV8_1MMainline", ",", "HasMVEInt", "]", ">", "{", "let", "D", "=" ]

[ "if", "(", "!", "EnableBasePointer", ")", "return", "false", ";" ]

[ "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "X86FI", "->", "hasPreallocatedCall", "(", ")", ")", "return", "true", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";" ]

[ "return", "Op", ";" ]

[ "SDValue", "Sc", "=", "DAG", ".", "getBitcast", "(", "tyScalar", "(", "InpTy", ")", ",", "InpV", ")", ";", "SDValue", "Ext", "=", "DAG", ".", "getZExtOrTrunc", "(", "Sc", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "return", "getInstr", "(", "Hexagon", "::", "C2_tfrrp", ",", "dl", ",", "ResTy", ",", "Ext", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "<STR_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "DecoderMethod", "=" ]

[ "}" ]

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

[ "FPRC", ":", "$", "Rn", ")", ",", "(", "OpVTy", "VPRC", ":", "$", "MRm", ")", ",", "OpImm", ":", "$", "Imm", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "ResTy", "(", "opnode", "(", "ResTy", "ResFPRC", ":", "$", "Ra", ")", ",", "(", "ResTy", "(", "coreopnode", "(", "OpTy", "FPRC", ":", "$", "Rn", ")", ",", "(", "OpTy", "(", "extract_subvector", "(", "OpVTy", "VPRC", ":", "$", "MRm", ")", ",", "OpImm", ":", "$", "Imm", ")", ")", ")", ")", ")", ")", ",", "(", "ResTy", "(", "INST", "(", "ResTy", "ResFPRC", ":", "$", "Ra", ")", ",", "(", "OpTy" ]

[ "<FIXS>", "[", "(", "call", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "call", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "}" ]

[ "case", "Intrinsic", "::", "r600_read_tidig_x", ":", "case", "Intrinsic", "::", "r600_read_tidig_y", ":", "case", "Intrinsic", "::", "r600_read_tidig_z", ":", "case", "Intrinsic", "::", "r600_read_local_size_x", ":", "case", "Intrinsic", "::", "r600_read_local_size_y", ":", "case", "Intrinsic", "::", "r600_read_local_size_z", ":", "Changed", "|=", "makeLIDRangeMetadata", "(", "F", ")", ";", "break", ";", "default", ":", "break", ";", "}" ]

[ "NewBase", ";" ]

[ "Register", "NewBase", ";", "int64_t", "NewOffset", ";", "if", "(", "mi_match", "(", "Root", ",", "MRI", ",", "m_GPtrAdd", "(", "m_Reg", "(", "NewBase", ")", ",", "m_ICst", "(", "NewOffset", ")", ")", ")", "&&", "isShiftedInt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "(", "NewOffset", ")", ")", "{", "Base", "=" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT_CC", ",", "DL", ",", "VT", ",", "Cond", ",", "HWFalse", ",", "True", ",", "False", ",", "DAG", ".", "getCondCode", "(", "ISD", "::", "SETNE", ")", ")", ";" ]

[ "ISD", "::", "CondCode", "InverseCC", "=", "ISD", "::", "getSetCCInverse", "(", "CCOpcode", ",", "CompareVT", "==", "MVT", "::", "i32", ")", ";", "if", "(", "isHWTrueValue", "(", "False", ")", "&&", "isHWFalseValue", "(", "True", ")", ")", "{", "if", "(", "isCondCodeLegal", "(", "InverseCC", ",", "CompareVT", ".", "getSimpleVT", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "False", ",", "True", ")", ";", "CC", "=", "DAG", ".", "getCondCode", "(", "InverseCC", ")", ";", "}", "else", "{", "ISD", "::", "CondCode", "SwapInvCC", "=", "ISD", "::", "getSetCCSwappedOperands", "(", "InverseCC", ")", ";", "if", "(", "isCondCodeLegal", "(", "SwapInvCC", ",", "CompareVT", ".", "getSimpleVT", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "False", ",", "True", ")", ";", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "CC", "=", "DAG", ".", "getCondCode", "(", "SwapInvCC", ")", ";", "}", "}", "}", "if", "(", "isHWTrueValue", "(", "True", ")", "&&", "isHWFalseValue", "(", "False", ")", "&&", "(", "CompareVT", "==", "VT", "||", "VT", "==", "MVT", "::", "i32", ")", ")", "{", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT_CC", ",", "DL", ",", "VT", ",", "LHS", ",", "RHS", ",", "True", ",", "False", ",", "CC", ")", ";", "}", "if", "(", "isZero", "(", "LHS", ")", ")", "{", "ISD", "::", "CondCode", "CCOpcode", "=", "cast", "<", "CondCodeSDNode", ">", "(", "CC", ")", "->", "get", "(", ")", ";", "ISD", "::", "CondCode", "CCSwapped", "=", "ISD", "::", "getSetCCSwappedOperands", "(", "CCOpcode", ")", ";", "if", "(", "isCondCodeLegal", "(", "CCSwapped", ",", "CompareVT", ".", "getSimpleVT", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "CC", "=", "DAG", ".", "getCondCode", "(", "CCSwapped", ")", ";", "}", "else", "{", "ISD", "::", "CondCode", "CCInv", "=", "ISD", "::", "getSetCCInverse", "(", "CCOpcode", ",", "CompareVT", ".", "isInteger", "(", ")", ")", ";", "CCSwapped", "=", "ISD", "::", "getSetCCSwappedOperands", "(", "CCInv", ")", ";", "if", "(", "isCondCodeLegal", "(", "CCSwapped", ",", "CompareVT", ".", "getSimpleVT", "(", ")", ")", ")", "{", "std", "::", "swap", "(", "True", ",", "False", ")", ";", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "CC", "=", "DAG", ".", "getCondCode", "(", "CCSwapped", ")", ";", "}", "}", "}", "if", "(", "isZero", "(", "RHS", ")", ")", "{", "SDValue", "Cond", "=", "LHS", ";", "SDValue", "Zero", "=", "RHS", ";", "ISD", "::", "CondCode", "CCOpcode", "=", "cast", "<", "CondCodeSDNode", ">", "(", "CC", ")", "->", "get", "(", ")", ";", "if", "(", "CompareVT", "!=", "VT", ")", "{", "True", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "CompareVT", ",", "True", ")", ";", "False", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "CompareVT", ",", "False", ")", ";", "}", "switch", "(", "CCOpcode", ")", "{", "case", "ISD", "::", "SETONE", ":", "case", "ISD", "::", "SETUNE", ":", "case", "ISD", "::", "SETNE", ":", "CCOpcode", "=", "ISD", "::", "getSetCCInverse", "(", "CCOpcode", ",", "CompareVT", "==", "MVT", "::", "i32", ")", ";", "Temp", "=", "True", ";", "True", "=", "False", ";", "False", "=", "Temp", ";", "break", ";", "default", ":", "break", ";", "}", "SDValue", "SelectNode", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT_CC", ",", "DL", ",", "CompareVT", ",", "Cond", ",", "Zero", ",", "True", ",", "False", ",", "DAG", ".", "getCondCode", "(", "CCOpcode", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "SelectNode", ")", ";", "}", "SDValue", "MinMax", "=", "LowerMinMax", "(", "Op", ",", "DAG", ")", ";", "if", "(", "MinMax", ".", "getNode", "(", ")", ")", "{", "return", "MinMax", ";", "}", "SDValue", "HWTrue", ",", "HWFalse", ";", "if", "(", "CompareVT", "==", "MVT", "::", "f32", ")", "{", "HWTrue", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "CompareVT", ")", ";", "HWFalse", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "CompareVT", ")", ";", "}", "else", "if", "(", "CompareVT", "==", "MVT", "::", "i32", ")", "{", "HWTrue", "=", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "CompareVT", ")", ";", "HWFalse", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "CompareVT", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled value type in LowerSELECT_CC", "<STR_LIT>", ")", ";", "}", "SDValue", "Cond", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT_CC", ",", "DL", ",", "CompareVT", ",", "LHS", ",", "RHS", ",", "HWTrue", ",", "HWFalse", ",", "CC", ")", ";" ]

[ "static", "inline", "CvtDirection", "getTombstoneKey", "(", ")", "{", "return", "{", "T_UNDEF", ",", "<NUM_LIT>", ";", "}" ]

[ "Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "." ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SF", "FPUL_REG", ")", "(", "mem", ":", "SF", "(", "post_inc", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "MBB", ".", "erase", "(", "I", ")", ";" ]

[ "adjustRegister", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "I", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Unknown call frame pseudo instruction", "<STR_LIT>", ")", ";", "adjustRegister", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Amount", ")", ";", "}", "}", "}" ]

[ "v2i64", ",", "v16i8", ">", ";" ]

[ "def", "v2i64", ":", "SHUFBVecInst", "<" ]

[ "(", "match_operand", ":", "<", "avx512fmaskmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", ")" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_merge", ":", "SUBST_V", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "SUBST_V", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "assert", "(", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", "&&", "<STR_LIT>", "custom lowering for unexpected type", "<STR_LIT>", ")", ";" ]

[ "return", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "SMAX", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "UMAX", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "STRICT_FP_TO_SINT", ":", "case", "ISD", "::", "STRICT_FP_TO_UINT", ":", "assert", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i128", "&&", "<STR_LIT>", "unexpected illegal conversion", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceCMP_SWAP_128Results", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD", ":", "case", "ISD", "::", "LOAD", ":", "{", "assert", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i128", "&&", "<STR_LIT>", "unexpected load's value type", "<STR_LIT>", ")", ";", "MemSDNode", "*", "LoadNode", "=", "cast", "<", "MemSDNode", ">", "(", "N", ")", ";", "if", "(", "(", "!", "LoadNode", "->", "isVolatile", "(", ")", "&&", "!", "LoadNode", "->", "isAtomic", "(", ")", ")", "||", "LoadNode", "->", "getMemoryVT", "(", ")", "!=", "MVT", "::", "i128", ")", "{", "return", ";", "}", "SDValue", "Result", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "DAG", ".", "getVTList", "(", "{", "MVT", "::", "i64", ",", "MVT", "::", "i64", ",", "MVT", "::", "Other", "}", ")", ",", "{", "LoadNode", "->", "getChain", "(", ")", ",", "LoadNode", "->", "getBasePtr", "(", ")", "}", ",", "LoadNode", "->", "getMemoryVT", "(", ")", ",", "LoadNode", "->", "getMemOperand", "(", ")", ")", ";", "SDValue", "Pair", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i128", ",", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "Results", ".", "append", "(", "{", "Pair", ",", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ")", ";", "return", ";", "}", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "ReplaceExtractSubVectorResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";" ]

[ ";" ]

[ "class", "DirectiveInsnRSI", "<", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "InstRSI", "<", "<NUM_LIT>", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "enc" ]

[ ")", "bitmap_set_bit", "(", "components", ",", "<NUM_LIT>", ")", ";" ]

[ "bitmap_clear", "(", "components", ")", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_gp_reg_save", ";", "regno", "<", "<NUM_LIT>", ";", "regno", "++", ")", "if", "(", "bitmap_bit_p", "(", "in", ",", "regno", ")", "||", "bitmap_bit_p", "(", "gen", ",", "regno", ")", "||", "bitmap_bit_p", "(", "kill", ",", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_fp_reg_save", ";", "regno", "<", "<NUM_LIT>", ";", "regno", "++", ")", "if", "(", "bitmap_bit_p", "(", "in", ",", "regno", ")", "||", "bitmap_bit_p", "(", "gen", ",", "regno", ")", "||", "bitmap_bit_p", "(", "kill", ",", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "if", "(", "bitmap_bit_p", "(", "in", ",", "LR_REGNO", ")", "||", "bitmap_bit_p", "(", "gen", ",", "LR_REGNO", ")", "||", "bitmap_bit_p", "(", "kill", ",", "LR_REGNO", ")" ]

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

[ "def", "v4i32_shift", ":", "BaseSIMDVectorShift", "<", "<NUM_LIT>", ",", "U", ",", "opc", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", "}", ",", "V128", ",", "V128", ",", "vecshiftR32", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4f32", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "v4i32", "V128", ":", "$", "Rn", ")", ",", "(", "i32", "imm", ":", "$", "imm", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";" ]

[ ";" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "AMDGPU Assembly Printer", "<STR_LIT>" ]

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

[ "(", "float", ":", "V2DF", "(", "vec_select", ":", "V2SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "let", "OperandType", "=", "OpType", ".", "FP32", ";" ]

[ "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "Switches", "=", "sw", ";" ]

[ "PPCU3ImmAsmOperand", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=" ]

[ "bool", "isBranchTarget", "(", ")", "const", "{", "if", "(", "!", "isImm", "(", ")", ")", "return", "false", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "if", "(", "!", "MCE", ")", "return", "true", ";", "int64_t", "Val", "=", "MCE", "->", "getValue", "(", ")", ";", "if", "(", "Val", "&", "<NUM_LIT>", ")", "return", "false", ";", "assert", "(", "N", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Branch target immediate cannot be 0 bits!", "<STR_LIT>", ")", ";", "return", "(", "Val", ">=", "-", "(", "(", "<NUM_LIT>", "<<", "(", "N", "-", "<NUM_LIT>", ")", ")", "<<", "<NUM_LIT>", ")", "&&", "Val", "<=", "(", "(", "(", "<NUM_LIT>", "<<", "(", "N", "-", "<NUM_LIT>", ")", ")", "-", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Set", "if", "this", "operand", "is", "a", "branch", "target", "." ]

[ "ID", ")", ";" ]

[ "ID", ".", "AddPointer", "(", "S", ")", ";", "ARMConstantPoolValue", "::", "addSelectionDAGCSEId", "(" ]

[ "<FIXS>", "const", "unsigned", "Reg", "=", "FirstDst", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", "?", "MRI", ".", "getRegClass", "(", "Reg", ")", ":", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "<FIXE>" ]

[ "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "<BUGS>", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "FirstDst", "->", "getReg", "(", ")", ")", ";", "<BUGE>", "return", "(", "NumLoads", "*", "(", "RI", ".", "getRegSizeInBits", "(", "*", "DstRC", ")", "/", "<NUM_LIT>", ")", ")", "<=", "LoadClusterThreshold", ";", "}" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rss32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rss32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Ru32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ru32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rxx32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rxx32", "{", "<NUM_LIT>", "-" ]

[ "const", "char", "*", "mips_output_sync", "(", "void", ")", "{", "mips_start_ll_sc_sync_block", "(", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "sync", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "mips_end_ll_sc_sync_block", "(", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "Output", "and/or", "return", "the", "asm", "template", "for", "a", "sync", "instruction", "." ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_macc_pd", "(", "_", "_", "m256d", "_", "_", "A", ",", "_", "_", "m256d", "_", "_", "B", ",", "_", "_", "m256d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_vfmaddpd256", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", ",", "(", "_", "_", "v4df", ")", "_", "_", "B", ",", "(", "_", "_", "v4df", ")", "_", "_", "C", ")", ";" ]

[ "}" ]

[ "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction requires a WASM feature not currently enabled", "<STR_LIT>", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction", "<STR_LIT>", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "<STR_LIT>", "ambiguous instruction", "<STR_LIT>", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";", "}" ]

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

[ "case", "DS_CNT", ":", "OS", "<<", "<STR_LIT>", " ", "<STR_LIT>", "<<", "(", "ST", "->", "hasExtendedWaitCounts", "(", ")", "?", "<STR_LIT>", "DS", "<STR_LIT>", ":", "<STR_LIT>", "LGKM", "<STR_LIT>", ")", "<<", "<STR_LIT>", "_CNT(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "case", "EXP_CNT", ":", "OS", "<<", "<STR_LIT>", " EXP_CNT(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "case", "STORE_CNT", ":", "OS", "<<", "<STR_LIT>", " ", "<STR_LIT>", "<<", "(", "ST", "->", "hasExtendedWaitCounts", "(", ")", "?", "<STR_LIT>", "STORE", "<STR_LIT>", ":", "<STR_LIT>", "VS", "<STR_LIT>", ")", "<<", "<STR_LIT>", "_CNT(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "case", "SAMPLE_CNT", ":", "OS", "<<", "<STR_LIT>", " SAMPLE_CNT(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "case", "BVH_CNT", ":", "OS", "<<", "<STR_LIT>", " BVH_CNT(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "case", "KM_CNT", ":", "OS", "<<", "<STR_LIT>", " KM_CNT(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "default", ":", "OS", "<<", "<STR_LIT>", " UNKNOWN(", "<STR_LIT>", "<<", "SR", "<<", "<STR_LIT>", "): ", "<STR_LIT>", ";", "break", ";", "}", "if", "(", "SR", "!=", "<NUM_LIT>", ")", "{", "unsigned", "LB", "=", "getScoreLB", "(", "T", ")", ";", "for", "(", "int", "J", "=", "<NUM_LIT>", ";", "J", "<=", "VgprUB", ";", "J", "++", ")", "{", "unsigned", "RegScore", "=", "getRegScore", "(", "J", ",", "T", ")", ";", "if", "(", "RegScore", "<=", "LB", ")", "continue", ";", "unsigned", "RelScore", "=", "RegScore", "-", "LB", "-", "<NUM_LIT>", ";", "if", "(", "J", "<", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ")", "{", "OS", "<<", "RelScore", "<<", "<STR_LIT>", ":v", "<STR_LIT>", "<<", "J" ]

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

[ "vminq_f32", "(", "float32x4_t", "_", "_", "a", ",", "float32x4_t" ]

[ ")", ";" ]

[ "uint32x2_t", "_", "_", "m", "=", "vpmin_u32", "(", "_", "_", "c", ",", "_", "_", "c", ")", ";", "return", "vreinterpret_u64_u32", "(", "_", "_", "m" ]

[ "DONE" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_BIG_ENDIAN", ")", "emit_insn", "(", "gen_smulhisi3_highpart_1", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", "else", "emit_insn", "(", "gen_smulhisi3_highpart_1", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")" ]

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

[ "def", "A2_sat", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_0ae0825c", ",", "TypeS_2op", ">", ",", "Enc_90cd8b", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-cpu", "<STR_LIT>", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "hasFnAttribute", "(", "<STR_LIT>", "use-soft-float", "<STR_LIT>", ")", "&&", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "use-soft-float", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", "==", "<STR_LIT>", "true", "<STR_LIT>", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "<STR_LIT>", "+soft-float", "<STR_LIT>", ":", "<STR_LIT>", ",+soft-float", "<STR_LIT>", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Pmode", ",", "out", ",", "<NUM_LIT>", ")", ")", ")", ";" ]

[ "emit_insn", "(", "gen_add2_insn", "(", "out", ",", "const1_rtx", ")", ")", ";", "if", "(", "align", "!=", "<NUM_LIT>", ")", "{", "emit_label", "(", "align_2_label", ")", ";", "emit_cmp_and_jump_insns", "(", "mem", ",", "const0_rtx", ",", "EQ", ",", "NULL", ",", "QImode", ",", "<NUM_LIT>", ",", "end_0_label", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "out", ",", "const1_rtx", ")", ")", ";", "emit_label", "(", "align_3_label", ")", ";", "}", "emit_cmp_and_jump_insns", "(", "mem", ",", "const0_rtx", ",", "EQ", ",", "NULL", ",", "QImode", ",", "<NUM_LIT>", ",", "end_0_label", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "out", ",", "const1_rtx", ")", ")", ";", "}", "emit_label", "(", "align_4_label", ")", ";", "mem", "=", "change_address", "(", "src", ",", "SImode", ",", "out", ")", ";", "emit_move_insn", "(", "scratch", ",", "mem", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "out", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "tmpreg", ",", "scratch", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_one_cmplsi2", "(", "scratch", ",", "scratch", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "tmpreg", ",", "tmpreg", ",", "scratch", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "tmpreg", ",", "tmpreg", ",", "gen_int_mode", "(", "<NUM_LIT>", ",", "SImode", ")", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "tmpreg", ",", "const0_rtx", ",", "EQ", ",", "<NUM_LIT>", ",", "SImode", ",", "<NUM_LIT>", ",", "align_4_label", ")", ";", "if", "(", "TARGET_CMOVE", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "reg2", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "reg", ",", "tmpreg", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_testsi_ccno_1", "(", "tmpreg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmpreg", ",", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "tmp", ",", "reg", ",", "tmpreg", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg2", ",", "plus_constant", "(" ]

[ "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "MaxEncoding", "=", "<NUM_LIT>", ";", "ShiftSize", "=", "<NUM_LIT>", ";", "if", "(", "Offset", "<", "<NUM_LIT>", ")", "{", "MaxEncoding", "=", "<NUM_LIT>", ";", "Sign", "=", "-", "<NUM_LIT>", ";", "Offset", "=", "-", "Offset", ";", "}", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode", "<STR_LIT>", ")", ";", "}", "int", "VScale", "=", "<NUM_LIT>", ";", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "VScale", "=", "<NUM_LIT>", ";", "else", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "VScale", "=", "<NUM_LIT>", ";", "const", "unsigned", "MaxEncodableValue", "=", "MaxEncoding", "<<", "ShiftSize", ";", "Register", "TmpReg", "=", "DestReg", ";", "if", "(", "TmpReg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "TmpReg", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "do", "{", "uint64_t", "ThisVal", "=", "std", "::", "min", "<", "uint64_t", ">", "(", "Offset", ",", "MaxEncodableValue", ")", ";", "unsigned", "LocalShiftSize", "=", "<NUM_LIT>", ";", "if", "(", "ThisVal", ">", "MaxEncoding", ")", "{", "ThisVal", "=", "ThisVal", ">>", "ShiftSize", ";", "LocalShiftSize", "=", "ShiftSize", ";", "}", "assert", "(", "(", "ThisVal", ">>", "ShiftSize", ")", "<=", "MaxEncoding", "&&", "<STR_LIT>", "Encoding cannot handle value that big", "<STR_LIT>", ")", ";", "Offset", "-=", "ThisVal", "<<", "LocalShiftSize", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "TmpReg", "=", "DestReg", ";", "auto", "MBI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ",", "TmpReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "Sign", "*", "(", "int", ")", "ThisVal", ")", ";", "if", "(", "ShiftSize", ")", "MBI", "=", "MBI", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "LocalShiftSize", ")", ")", ";", "MBI", "=", "MBI", ".", "setMIFlag", "(", "Flag", ")", ";", "auto", "Change", "=", "VScale", "==", "<NUM_LIT>", "?", "StackOffset", "::", "getFixed", "(", "ThisVal", "<<", "LocalShiftSize", ")", ":", "StackOffset", "::", "getScalable", "(", "VScale", "*", "(", "ThisVal", "<<", "LocalShiftSize", ")", ")", ";", "if", "(", "Sign", "==", "-", "<NUM_LIT>", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "CFAOffset", "+=", "Change", ";", "else", "CFAOffset", "-=", "Change", ";", "if", "(", "EmitCFAOffset", "&&", "DestReg", "==", "TmpReg", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";" ]

[ "decl", "=", "add_builtin_function", "(", "<STR_LIT>", "__builtin_umulsidi3", "<STR_LIT>", ",", "ftype", ",", "XTENSA_BUILTIN_UMULSIDI3", ",", "BUILT_IN_MD", ",", "<STR_LIT>", "__umulsidi3", "<STR_LIT>", ",", "NULL_TREE", ")", ";" ]

[ "static", "void", "xtensa_init_builtins", "(", "void", ")", "{", "tree", "ftype", ",", "decl", ";", "ftype", "=", "build_function_type_list", "(", "unsigned_intDI_type_node", ",", "unsigned_intSI_type_node", ",", "unsigned_intSI_type_node", ",", "NULL_TREE", ")", ";" ]

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

[ "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_mod", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Can't store this register to stack slot", "<STR_LIT>", ")", ";", "}", "}" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

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

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

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

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

[ "}" ]

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

[ "case", "LINUX_V4_15", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";" ]

[ "void", "bpf_target_macros", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "<STR_LIT>", "__BPF__", "<STR_LIT>", ")", ";", "builtin_define", "(", "<STR_LIT>", "__bpf__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "<STR_LIT>", "__BPF_BIG_ENDIAN__", "<STR_LIT>", ")", ";", "else", "builtin_define", "(", "<STR_LIT>", "__BPF_LITTLE_ENDIAN__", "<STR_LIT>", ")", ";", "{", "const", "char", "*", "version_code", ";", "char", "*", "kernel_version_code", ";", "switch", "(", "bpf_kernel", ")", "{", "case", "LINUX_V4_0", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_1", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_2", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_3", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_4", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_5", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_6", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_7", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_8", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_9", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_10", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_11", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_12", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_13", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";", "case", "LINUX_V4_14", ":", "version_code", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "break", ";" ]

[ "_", "_", "B", ",", "(", "_", "_", "v32hi", ")", "_", "mm512_setzero_hi", "(", ")", ",", "(", "_", "_", "mmask32", ")", "_", "_", "M", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pmaxsw512_mask", "(", "(", "_", "_", "v32hi", ")", "_", "_", "A", ",", "(", "_", "_", "v32hi", ")" ]

[ "<FIXS>", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "<BUGS>", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "<BUGE>", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";" ]

[ "let", "ParserMatchClass", "=", "LogicalVecHalfWordShifterOperand", ";" ]

[ "def", "logical_vec_hw_shift", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "lane", "{", "<NUM_LIT>", "}", ";" ]

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

[ "}" ]

[ "def", "_S_register", ":", "STN_WBReg_Lane", "<", "r", ",", "<NUM_LIT>", ",", "op0", ",", "!", "cast", "<", "RegisterOperand", ">", "(", "List", "#", "<STR_LIT>", ")", ",", "uimm_s", ",", "neon_uimm2_bare", ",", "asmop", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "{", "lane", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "}", ";" ]

[ "=", "Rd", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "cond", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "cond", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

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

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

[ "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "}", "return", "nullptr", ";", "}" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "MBB", ".", "erase", "(", "MBBI", ")", ";" ]

[ "unsigned", "Opcode", "=", "PrevMI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ARM", "::", "LDMIA_UPD", "||", "Opcode", "==", "ARM", "::", "LDMDA_UPD", "||", "Opcode", "==", "ARM", "::", "LDMDB_UPD", "||", "Opcode", "==", "ARM", "::", "LDMIB_UPD", "||", "Opcode", "==", "ARM", "::", "t2LDMIA_UPD", "||", "Opcode", "==", "ARM", "::", "t2LDMDB_UPD", ")", "{", "MachineOperand", "&", "MO", "=", "PrevMI", "->", "getOperand", "(", "PrevMI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "if", "(", "MO", ".", "getReg", "(", ")", "!=", "ARM", "::", "LR", ")", "return", "false", ";", "unsigned", "NewOpc", "=", "(", "isThumb2", "?", "ARM", "::", "t2LDMIA_RET", ":", "ARM", "::", "LDMIA_RET", ")", ";", "assert", "(", "(", "(", "isThumb2", "&&", "Opcode", "==", "ARM", "::", "t2LDMIA_UPD", ")", "||", "Opcode", "==", "ARM", "::", "LDMIA_UPD", ")", "&&", "<STR_LIT>", "Unsupported multiple load-return!", "<STR_LIT>", ")", ";", "PrevMI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpc", ")", ")", ";", "MO", ".", "setReg", "(", "ARM", "::", "PC", ")", ";", "PrevMI", "->", "copyImplicitOps", "(", "&", "*", "MBBI", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "HWWriteResGroup1", ":", "SchedWriteRes", "<", "[", "HWPort4", ",", "HWPort237", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=" ]

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

[ "vaddhn_u64", "(", "uint64x2_t", "_", "_", "a", ",", "uint64x2_t", "_" ]

[ "unsigned", "Reloc", "=", "(", "(", "TID", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "ARM", "::", "reloc_arm_vfp_cp_entry", ":", "ARM", "::", "reloc_arm_cp_entry", ";" ]

[ "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "{", "const", "TargetInstrDesc", "&", "TID", "=", "MI", ".", "getDesc", "(", ")", ";" ]

[ "}" ]

[ "def", "Wi", ":", "BaseInsertImmediate", "<", "opc", ",", "GPR32", ",", "movimm32_shift", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

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

[ "<FIXS>", "typename", "Operand", ",", "typename", "Bundleable", "<FIXE>" ]

[ "template", "typename", "Instruction", ",", "typename", "InstrIter", ",", "<BUGS>", "typename", "Operand", "<BUGE>", "Optional", "std", "::", "shared_ptr", "Node", ">>", "get_next_ready", "(", "InstrIter", "instr_begin", ",", "InstrIter", "instr_end", "," ]

[ "get", "(", "WebAssembly", "::", "END_BLOCK", ")", ")", ";" ]

[ "}", "else", "{", "InsertPos", "=", "Header", "->", "getFirstTerminator", "(", ")", ";", "while", "(", "InsertPos", "!=", "Header", "->", "begin", "(", ")", "&&", "WebAssembly", "::", "isChild", "(", "*", "std", "::", "prev", "(", "InsertPos", ")", ",", "MFI", ")", "&&", "std", "::", "prev", "(", "InsertPos", ")", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "LOOP", "&&", "std", "::", "prev", "(", "InsertPos", ")", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "END_BLOCK", "&&", "std", "::", "prev", "(", "InsertPos", ")", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "END_LOOP", ")", "--", "InsertPos", ";", "}", "MachineInstr", "*", "Begin", "=", "BuildMI", "(", "*", "Header", ",", "InsertPos", ",", "MBB", ".", "findDebugLoc", "(", "InsertPos", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "BLOCK", ")", ")", ".", "addImm", "(", "int64_t", "(", "WebAssembly", "::", "ExprType", "::", "Void", ")", ")", ";", "InsertPos", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "InsertPos", "!=", "MBB", ".", "end", "(", ")", "&&", "InsertPos", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "END_LOOP", "&&", "LoopTops", "[", "&", "*", "InsertPos", "]", "->", "getParent", "(", ")", "->", "getNumber", "(", ")", ">=", "Header", "->", "getNumber", "(", ")", ")", "++", "InsertPos", ";", "MachineInstr", "*", "End", "=", "BuildMI", "(", "MBB", ",", "InsertPos", ",", "MBB", ".", "findPrevDebugLoc", "(", "InsertPos", ")", ",", "TII", "." ]

[ "*", "no_add_attrs", "=", "true", ";" ]

[ "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "gcc_assert", "(", "args", "==", "NULL", ")", ";", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "has_attr", "(", "ATTR_NOINIT", ",", "*", "node", ")", "&&", "!", "TREE_NAME_EQ", "(", "name", ",", "<STR_LIT>", "lower", "<STR_LIT>", ")", ")", "message", "=", "G_", "(", "<STR_LIT>", "ignoring attribute %qE because it conflicts with ", "<STR_LIT>", "<STR_LIT>", "attribute %<noinit%>", "<STR_LIT>", ")", ";", "else", "if", "(", "has_attr", "(", "<STR_LIT>", "section", "<STR_LIT>", ",", "*", "node", ")", "&&", "!", "TREE_NAME_EQ", "(", "name", ",", "<STR_LIT>", "lower", "<STR_LIT>", ")", ")", "message", "=", "G_", "(", "<STR_LIT>", "ignoring attribute %qE because it conflicts with ", "<STR_LIT>", "<STR_LIT>", "attribute %<section%>", "<STR_LIT>", ")", ";", "else", "if", "(", "has_attr", "(", "ATTR_PERSIST", ",", "*", "node", ")", "&&", "!", "TREE_NAME_EQ", "(", "name", ",", "<STR_LIT>", "lower", "<STR_LIT>", ")", ")", "message", "=", "G_", "(", "<STR_LIT>", "ignoring attribute %qE because it conflicts with ", "<STR_LIT>", "<STR_LIT>", "attribute %<persistent%>", "<STR_LIT>", ")", ";", "else", "if", "(", "!", "TARGET_LARGE", ")", "message", "=", "G_", "(", "<STR_LIT>", "%qE attribute ignored. Large memory model (%<-mlarge%>) ", "<STR_LIT>", "<STR_LIT>", "is required.", "<STR_LIT>", ")", ";", "if", "(", "message", ")", "{", "warning", "(", "OPT_Wattributes", ",", "message", ",", "name", ")", ";" ]

[ "rtx", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "{", "machine_mode", "mode", "=", "<", "VALL_F16", ":", "MODE", ">", "mode" ]

[ "<FIXS>", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "<NUM_LIT>", ";", "return", "count", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ";", "<FIXE>" ]

[ "par", "=", "emit_insn", "(", "par", ")", ";", "REG_NOTES", "(", "par", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ",", "REG_NOTES", "(", "par", ")", ")", ";", "<BUGS>", "return", "par", ";", "<BUGE>", "}" ]

[ "const", "{" ]

[ "bool", "isToken", "(", ")" ]

[ "if", "(", "isa", "<", "ReturnInst", ">", "(", "TI", ")", ")", "CallInst", "::", "CreateFree", "(", "SetjmpTable", ",", "TI", ")", ";" ]

[ "assert", "(", "!", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", ";", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "CI", ")", "continue", ";", "const", "Value", "*", "Callee", "=", "CI", "->", "getCalledValue", "(", ")", ";", "if", "(", "!", "canLongjmp", "(", "M", ",", "Callee", ")", ")", "continue", ";", "Value", "*", "Threw", "=", "nullptr", ";", "BasicBlock", "*", "Tail", ";", "if", "(", "Callee", "->", "getName", "(", ")", ".", "startswith", "(", "InvokePrefix", ")", ")", "{", "LoadInst", "*", "ThrewLI", "=", "nullptr", ";", "StoreInst", "*", "ThrewResetSI", "=", "nullptr", ";", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "BasicBlock", "::", "iterator", "(", "CI", ")", ")", ",", "IE", "=", "BB", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "{", "if", "(", "auto", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "I", ")", ")", "if", "(", "auto", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "LI", "->", "getPointerOperand", "(", ")", ")", ")", "if", "(", "GV", "==", "ThrewGV", ")", "{", "Threw", "=", "ThrewLI", "=", "LI", ";", "break", ";", "}", "}", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "BasicBlock", "::", "iterator", "(", "ThrewLI", ")", ")", ",", "IE", "=", "BB", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "{", "if", "(", "auto", "*", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "I", ")", ")", "if", "(", "auto", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "SI", "->", "getPointerOperand", "(", ")", ")", ")", "if", "(", "GV", "==", "ThrewGV", "&&", "SI", "->", "getValueOperand", "(", ")", "==", "IRB", ".", "getInt32", "(", "<NUM_LIT>", ")", ")", "{", "ThrewResetSI", "=", "SI", ";", "break", ";", "}", "}", "assert", "(", "Threw", "&&", "ThrewLI", "&&", "<STR_LIT>", "Cannot find __THREW__ load after invoke", "<STR_LIT>", ")", ";", "assert", "(", "ThrewResetSI", "&&", "<STR_LIT>", "Cannot find __THREW__ store after invoke", "<STR_LIT>", ")", ";", "Tail", "=", "SplitBlock", "(", "BB", ",", "ThrewResetSI", "->", "getNextNode", "(", ")", ")", ";", "}", "else", "{", "Threw", "=", "wrapInvoke", "(", "CI", ")", ";", "ToErase", ".", "push_back", "(", "CI", ")", ";", "Tail", "=", "SplitBlock", "(", "BB", ",", "CI", "->", "getNextNode", "(", ")", ")", ";", "}", "ToErase", ".", "push_back", "(", "BB", "->", "getTerminator", "(", ")", ")", ";", "Value", "*", "Label", "=", "nullptr", ";", "Value", "*", "LongjmpResult", "=", "nullptr", ";", "BasicBlock", "*", "EndBB", "=", "nullptr", ";", "wrapTestSetjmp", "(", "BB", ",", "CI", ",", "Threw", ",", "SetjmpTable", ",", "SetjmpTableSize", ",", "Label", ",", "LongjmpResult", ",", "EndBB", ")", ";", "assert", "(", "Label", "&&", "LongjmpResult", "&&", "EndBB", ")", ";", "IRB", ".", "SetInsertPoint", "(", "EndBB", ")", ";", "SwitchInst", "*", "SI", "=", "IRB", ".", "CreateSwitch", "(", "Label", ",", "Tail", ",", "SetjmpRetPHIs", ".", "size", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "SetjmpRetPHIs", ".", "size", "(", ")", ";", "I", "++", ")", "{", "SI", "->", "addCase", "(", "IRB", ".", "getInt32", "(", "I", "+", "<NUM_LIT>", ")", ",", "SetjmpRetPHIs", "[", "I", "]", "->", "getParent", "(", ")", ")", ";", "SetjmpRetPHIs", "[", "I", "]", "->", "addIncoming", "(", "LongjmpResult", ",", "EndBB", ")", ";", "}", "BBs", ".", "push_back", "(", "Tail", ")", ";", "}", "}", "for", "(", "Instruction", "*", "I", ":", "ToErase", ")", "I", "->", "eraseFromParent", "(", ")", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "Instruction", "*", "TI", "=", "BB", ".", "getTerminator", "(", ")", ";" ]

[ "}" ]

[ "assert", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", "->", "getAllocatableSet", "(", "MF", ")", ".", "test", "(", "R", ")", "&&", "<STR_LIT>", "Shouldn't move an instruction with unallocatable registers across ", "<STR_LIT>", "<STR_LIT>", "basic block boundaries.", "<STR_LIT>", ")", ";", "if", "(", "!", "MBB", ".", "isLiveIn", "(", "R", ")", ")", "MBB", ".", "addLiveIn", "(", "R", ")", ";" ]

[ "_", "result", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_move_sd", "(", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B", ")", "{", "_", "_", "v2df", "_", "_", "result", "=", "(", "_", "_", "v2df", ")", "_", "_", "A", ";", "_", "_", "result", "[", "<NUM_LIT>", "]", "=", "(", "(", "_", "_", "v2df", ")", "_", "_", "B", ")", "[", "<NUM_LIT>", "]", ";", "return", "(", "_", "_", "m128d", ")", "_" ]

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

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps" ]

[ "static", "tree", "alpha_fold_builtin", "(", "tree", "fndecl", ",", "int", "n_args", ",", "tree", "*", "op", ",", "bool", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "HOST_WIDE_INT", "opint", "[", "MAX_ARGS", "]", ";", "long", "op_const", "=", "<NUM_LIT>", ";", "int", "i", ";", "if", "(", "n_args", ">", "MAX_ARGS", ")", "return", "NULL", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_args", ";", "i", "++", ")", "{", "tree", "arg", "=", "op", "[", "i", "]", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL", ";", "opint", "[", "i", "]", "=", "<NUM_LIT>", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "==", "INTEGER_CST", ")", "{", "op_const", "|=", "<NUM_LIT>", "L", "<<", "i", ";", "opint", "[", "i", "]", "=", "int_cst_value", "(", "arg", ")", ";", "}", "}", "switch", "(", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "ALPHA_BUILTIN_CMPBGE", ":", "return", "alpha_fold_builtin_cmpbge", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_EXTBL", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_EXTWL", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_EXTLL", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_EXTQL", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_EXTWH", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_EXTLH", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_EXTQH", ":", "return", "alpha_fold_builtin_extxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_INSBL", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_INSWL", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_INSLL", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_INSQL", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_INSWH", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_INSLH", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_INSQH", ":", "return", "alpha_fold_builtin_insxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_MSKBL", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_MSKWL", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_MSKLL", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_MSKQL", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "false", ")", ";", "case", "ALPHA_BUILTIN_MSKWH", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_MSKLH", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_MSKQH", ":", "return", "alpha_fold_builtin_mskxx", "(", "op", ",", "opint", ",", "op_const", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "ALPHA_BUILTIN_ZAP", ":", "opint", "[", "<NUM_LIT>", "]", "^=", "<NUM_LIT>", ";", "case", "ALPHA_BUILTIN_ZAPNOT", ":", "return", "alpha_fold_builtin_zapnot", "(", "op", ",", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_MINUB8", ":", "return", "alpha_fold_vector_minmax", "(", "MIN_EXPR", ",", "op", ",", "alpha_v8qi_u", ")", ";", "case", "ALPHA_BUILTIN_MINSB8", ":", "return", "alpha_fold_vector_minmax", "(", "MIN_EXPR", ",", "op", ",", "alpha_v8qi_s", ")", ";", "case", "ALPHA_BUILTIN_MINUW4", ":", "return", "alpha_fold_vector_minmax", "(", "MIN_EXPR", ",", "op", ",", "alpha_v4hi_u", ")", ";", "case", "ALPHA_BUILTIN_MINSW4", ":", "return", "alpha_fold_vector_minmax", "(", "MIN_EXPR", ",", "op", ",", "alpha_v4hi_s", ")", ";", "case", "ALPHA_BUILTIN_MAXUB8", ":", "return", "alpha_fold_vector_minmax", "(", "MAX_EXPR", ",", "op", ",", "alpha_v8qi_u", ")", ";", "case", "ALPHA_BUILTIN_MAXSB8", ":", "return", "alpha_fold_vector_minmax", "(", "MAX_EXPR", ",", "op", ",", "alpha_v8qi_s", ")", ";", "case", "ALPHA_BUILTIN_MAXUW4", ":", "return", "alpha_fold_vector_minmax", "(", "MAX_EXPR", ",", "op", ",", "alpha_v4hi_u", ")", ";", "case", "ALPHA_BUILTIN_MAXSW4", ":", "return", "alpha_fold_vector_minmax", "(", "MAX_EXPR", ",", "op", ",", "alpha_v4hi_s", ")", ";", "case", "ALPHA_BUILTIN_PERR", ":", "return", "alpha_fold_builtin_perr", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_PKLB", ":", "return", "alpha_fold_builtin_pklb", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_PKWB", ":", "return", "alpha_fold_builtin_pkwb", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_UNPKBL", ":", "return", "alpha_fold_builtin_unpkbl", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_UNPKBW", ":", "return", "alpha_fold_builtin_unpkbw", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_CTTZ", ":", "return", "alpha_fold_builtin_cttz", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_CTLZ", ":", "return", "alpha_fold_builtin_ctlz", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_CTPOP", ":", "return", "alpha_fold_builtin_ctpop", "(", "opint", ",", "op_const", ")", ";", "case", "ALPHA_BUILTIN_AMASK", ":", "case", "ALPHA_BUILTIN_IMPLVER", ":", "case", "ALPHA_BUILTIN_RPCC", ":", "default", ":", "return", "NULL", ";", "}", "}" ]

[ "Fold", "one", "of", "our", "builtin", "functions", "." ]

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

[ "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "MFI", "->", "hasWorkGroupInfo", "(", ")", ")", "|", "S_00B84C_TIDIG_COMP_CNT", "(", "TIDIGCompCnt", ")", "|", "S_00B84C_EXCP_EN_MSB", "(", "<NUM_LIT>", ")", "|", "S_00B84C_LDS_SIZE", "(", "ProgInfo", ".", "LDSBlocks", ")", "|", "S_00B84C_EXCP_EN", "(", "<NUM_LIT>", ")", ";" ]

[ "isSGPR", "=", "false", ";", "width", "=", "<NUM_LIT>", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unknown register class", "<STR_LIT>", ")", ";", "}", "unsigned", "hwReg", "=", "RI", "->", "getEncodingValue", "(", "reg", ")", "&", "<NUM_LIT>", ";", "unsigned", "maxUsed", "=", "hwReg", "+", "width", "-", "<NUM_LIT>", ";", "if", "(", "isSGPR", ")", "{", "MaxSGPR", "=", "maxUsed", ">", "MaxSGPR", "?", "maxUsed", ":", "MaxSGPR", ";", "}", "else", "{", "MaxVGPR", "=", "maxUsed", ">", "MaxVGPR", "?", "maxUsed", ":", "MaxVGPR", ";", "}", "}", "}", "}", "unsigned", "ExtraSGPRs", "=", "<NUM_LIT>", ";", "if", "(", "VCCUsed", ")", "ExtraSGPRs", "=", "<NUM_LIT>", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "FlatUsed", ")", "ExtraSGPRs", "=", "<NUM_LIT>", ";", "}", "else", "{", "if", "(", "STM", ".", "isXNACKEnabled", "(", ")", ")", "ExtraSGPRs", "=", "<NUM_LIT>", ";", "if", "(", "FlatUsed", ")", "ExtraSGPRs", "=", "<NUM_LIT>", ";", "}", "MaxSGPR", "+=", "ExtraSGPRs", ";", "ProgInfo", ".", "NumVGPR", "=", "MaxVGPR", "+", "<NUM_LIT>", ";", "ProgInfo", ".", "NumSGPR", "=", "MaxSGPR", "+", "<NUM_LIT>", ";", "if", "(", "STM", ".", "hasSGPRInitBug", "(", ")", ")", "{", "if", "(", "ProgInfo", ".", "NumSGPR", ">", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "too many SGPRs used with the SGPR init bug", "<STR_LIT>", ")", ";", "}", "ProgInfo", ".", "NumSGPR", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", ";", "}", "if", "(", "MFI", "->", "NumUserSGPRs", ">", "STM", ".", "getMaxNumUserSGPRs", "(", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "too many user SGPRs used", "<STR_LIT>", ")", ";", "}", "ProgInfo", ".", "VGPRBlocks", "=", "(", "ProgInfo", ".", "NumVGPR", "-", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "ProgInfo", ".", "SGPRBlocks", "=", "(", "ProgInfo", ".", "NumSGPR", "-", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "ProgInfo", ".", "FloatMode", "=", "getFPMode", "(", "MF", ")", ";", "ProgInfo", ".", "IEEEMode", "=", "<NUM_LIT>", ";", "ProgInfo", ".", "DX10Clamp", "=", "<NUM_LIT>", ";", "const", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ProgInfo", ".", "ScratchSize", "=", "FrameInfo", "->", "estimateStackSize", "(", "MF", ")", ";", "ProgInfo", ".", "FlatUsed", "=", "FlatUsed", ";", "ProgInfo", ".", "VCCUsed", "=", "VCCUsed", ";", "ProgInfo", ".", "CodeLen", "=", "CodeSize", ";", "unsigned", "LDSAlignShift", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "LDSAlignShift", "=", "<NUM_LIT>", ";", "}", "else", "{", "LDSAlignShift", "=", "<NUM_LIT>", ";", "}", "unsigned", "LDSSpillSize", "=", "MFI", "->", "LDSWaveSpillSize", "*", "MFI", "->", "getMaximumWorkGroupSize", "(", "MF", ")", ";", "ProgInfo", ".", "LDSSize", "=", "MFI", "->", "LDSSize", "+", "LDSSpillSize", ";", "ProgInfo", ".", "LDSBlocks", "=", "RoundUpToAlignment", "(", "ProgInfo", ".", "LDSSize", ",", "<NUM_LIT>", "<<", "LDSAlignShift", ")", ">>", "LDSAlignShift", ";", "unsigned", "ScratchAlignShift", "=", "<NUM_LIT>", ";", "ProgInfo", ".", "ScratchBlocks", "=", "RoundUpToAlignment", "(", "ProgInfo", ".", "ScratchSize", "*", "STM", ".", "getWavefrontSize", "(", ")", ",", "<NUM_LIT>", "<<", "ScratchAlignShift", ")", ">>", "ScratchAlignShift", ";", "ProgInfo", ".", "ComputePGMRSrc1", "=", "S_00B848_VGPRS", "(", "ProgInfo", ".", "VGPRBlocks", ")", "|", "S_00B848_SGPRS", "(", "ProgInfo", ".", "SGPRBlocks", ")", "|", "S_00B848_PRIORITY", "(", "ProgInfo", ".", "Priority", ")", "|", "S_00B848_FLOAT_MODE", "(", "ProgInfo", ".", "FloatMode", ")", "|", "S_00B848_PRIV", "(", "ProgInfo", ".", "Priv", ")", "|", "S_00B848_DX10_CLAMP", "(", "ProgInfo", ".", "DX10Clamp", ")", "|", "S_00B848_DEBUG_MODE", "(", "ProgInfo", ".", "DebugMode", ")", "|", "S_00B848_IEEE_MODE", "(", "ProgInfo", ".", "IEEEMode", ")", ";", "unsigned", "TIDIGCompCnt", "=", "<NUM_LIT>", ";", "if", "(", "MFI", "->", "hasWorkItemIDZ", "(", ")", ")", "TIDIGCompCnt", "=", "<NUM_LIT>", ";", "else", "if", "(", "MFI", "->", "hasWorkItemIDY", "(", ")", ")", "TIDIGCompCnt", "=", "<NUM_LIT>", ";", "ProgInfo", ".", "ComputePGMRSrc2", "=", "S_00B84C_SCRATCH_EN", "(", "ProgInfo", ".", "ScratchBlocks", ">", "<NUM_LIT>", ")", "|", "S_00B84C_USER_SGPR", "(", "MFI", "->", "getNumUserSGPRs", "(", ")", ")", "|", "S_00B84C_TGID_X_EN", "(", "MFI", "->", "hasWorkGroupIDX", "(", ")", ")", "|", "S_00B84C_TGID_Y_EN", "(", "MFI", "->", "hasWorkGroupIDY", "(", ")", ")", "|", "S_00B84C_TGID_Z_EN", "(", "MFI", "->", "hasWorkGroupIDZ", "(", ")", ")", "|", "S_00B84C_TG_SIZE_EN", "(" ]

[ "TVM Lower Intrinsics", "<STR_LIT>", ";" ]

[ "return", "<STR_LIT>" ]

[ "}" ]

[ "unsigned", "Register", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ".", "getRegister", "(", "RegNo", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Register", ")", ")", ";", "return", "Success", ";" ]

[ "}" ]

[ "static", "unsigned", "getHashValue", "(", "const", "CvtDirection", "&", "Val", ")", "{", "return", "(", "Val", ".", "SourceType", "^", "Val", ".", "DestinationType", ")", "*", "<NUM_LIT>", "U", ";" ]

[ "x", ")", ";" ]

[ "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\nrs6000_rtx_costs, return = %s, mode = %s, outer_code = %s, ", "<STR_LIT>", "<STR_LIT>", "opno = %d, total = %d, speed = %s, x:\\n", "<STR_LIT>", ",", "ret", "?", "<STR_LIT>", "complete", "<STR_LIT>", ":", "<STR_LIT>", "scan inner", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "GET_RTX_NAME", "(", "outer_code", ")", ",", "opno", ",", "*", "total", ",", "speed", "?", "<STR_LIT>", "true", "<STR_LIT>", ":", "<STR_LIT>", "false", "<STR_LIT>", ")", ";", "debug_rtx", "(" ]

[ "+", "<STR_LIT>", "func_gep", "<STR_LIT>", "+", "Twine", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ")", ";" ]

[ "return", "MF", ".", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Twine", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ")" ]

[ ",", "GEN_INT", "(", "d1", ")", ")", ")", ";" ]

[ "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "rtx", "or", "ig_target", "=", "target", ";", "d1", "=", "(", "(", "c1", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "c1", "-=", "d1", ";", "d2", "=", "(", "(", "c1", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "c1", "=", "(", "c1", "-", "d2", ")", ">>", "<NUM_LIT>", ";", "d3", "=", "(", "(", "c1", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "c1", "-=", "d3", ";", "d4", "=", "(", "(", "c1", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "gcc_assert", "(", "c1", "==", "d4", ")", ";", "if", "(", "mode", "!=", "DImode", ")", "target", "=", "gen_lowpart", "(", "DImode", ",", "target", ")", ";", "if", "(", "d4", ")", "{", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "d4", ")", ")", ";", "if", "(", "d3", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d3", ")", ")", ")", ";", "}", "else", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "d3", ")", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "d2", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d2", ")", ")", ")", ";", "if", "(", "d1", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target" ]

[ "getStreamer", "(", ")", ".", "emitWinCFIPushReg", "(", "Reg", ",", "Loc", ")", ";" ]

[ "unsigned", "Reg", "=", "<NUM_LIT>", ";", "if", "(", "parseSEHRegisterNumber", "(", "X86", "::", "GR64RegClassID", ",", "Reg", ")", ")", "return", "true", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "TokError", "(", "<STR_LIT>", "unexpected token in directive", "<STR_LIT>", ")", ";", "getParser", "(", ")", ".", "Lex", "(", ")", ";" ]

[ "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "REG_RA", ")", ";" ]

[ "rtx", "alpha_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "<NUM_LIT>", ")", "return", "const0_rtx", ";" ]

[ ")", "->", "getNode", "(", "VersionMajorV5", ")", ")", ";" ]

[ "auto", "Version", "=", "HSAMetadataDoc", "->", "getArrayNode", "(", ")", ";", "Version", ".", "push_back", "(", "Version", ".", "getDocument", "(" ]

[ "SDValue", "LanaiTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "DL", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "IsTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "IsTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "IsVarArg", ",", "IsTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "DL", ",", "DAG", ",", "InVals", ")", ";", "default", ":", "report_fatal_error", "(", "<STR_LIT>", "Unsupported calling convention", "<STR_LIT>", ")", ";", "}", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "<FIXS>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "{", "return", "MOTOROLA", "?", "<STR_LIT>", ":", "<STR_LIT>", "<BUGS>", "}", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]