Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "M68k", "::", "LEA32q", ")", ",", "GlobalBaseReg", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "_GLOBAL_OFFSET_TABLE_", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "M68kMachineFunctionInfo", "*", "MxFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MxFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "const", "M68kInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";" ]

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

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

[ "DL", ")", ";" ]

[ "if", "(", "const", "auto", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ";", "Arg", "&&", "Arg", "->", "hasNonNullAttr", "(", ")", ")", "return", "true", ";", "if", "(", "AS", "!=", "cast", "<", "PointerType", ">", "(", "V", "->", "getType", "(", ")", ")", "->", "getAddressSpace", "(", ")", ")", "return", "false", ";", "auto", "SrcPtrKB", "=", "computeKnownBits", "(", "V", "," ]

[ "}" ]

[ "if", "(", "!", "AM", ".", "isDispAddrType", "(", ")", ")", "return", "false", ";", "return", "isIntN", "(", "AM", ".", "getDispSize", "(", ")", "-", "<NUM_LIT>", ",", "AM", ".", "Disp", ")", ";" ]

[ ";" ]

[ "void", "setUsesRedZone", "(", "bool", "V", ")", "{", "UsesRedZone", "=", "V" ]

[ "->", "getRegInfo", "(", ")", ";" ]

[ "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "<STR_LIT>", "__chkstk is only supported on Windows", "<STR_LIT>", ")", ";", "assert", "(", "Subtarget", "->", "isThumb2", "(", ")", "&&", "<STR_LIT>", "Windows on ARM requires Thumb-2 mode", "<STR_LIT>", ")", ";", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Medium", ":", "case", "CodeModel", "::", "Default", ":", "case", "CodeModel", "::", "Kernel", ":", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tBL", ")", ")", ".", "addImm", "(", "(", "unsigned", ")", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "__chkstk", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "R4", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ".", "addReg", "(", "ARM", "::", "R4", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ";", "break", ";", "case", "CodeModel", "::", "Large", ":", "case", "CodeModel", "::", "JITDefault", ":", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")" ]

[ "Changed", ";" ]

[ "MachineBasicBlock", "::", "iterator", "I", ",", "E", ",", "NextI", ";", "for", "(", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "NextI", ")", "{", "NextI", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "isCondset", "(", "*", "I", ")", ")", "Changed", "|=", "split", "(", "*", "I", ",", "UpdRegs", ")", ";", "}", "return" ]

[ "true", ";" ]

[ "for", "(", "MachineBasicBlock", "::", "reverse_iterator", "I", "=", "B", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "definesRegister", "(", "reg", ")", ")", "{", "return", "true", ";", "}", "if", "(", "I", "->", "readsRegister", "(", "reg", ")", "&&", "(", "HSAIL", "::", "isConv", "(", "&", "*", "I", ")", "||", "I", "->", "mayStore", "(", ")", ")", ")", "{", "canBeSpilled", "=", "true", ";", "return" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "op3", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "SrcC", "=", "op3", ";", "let", "SrcD", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "hasSrcC", "=", "<NUM_LIT>", ";", "let", "hasSrcD", "=", "<NUM_LIT>", ";", "bit", "HasImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src1", ")", ";" ]

[ ")" ]

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

[ "<FIXS>", "[", "(", "arm_cmpfpe", "HPR", ":", "$", "Sd", ",", "HPR", ":", "$", "Sm", ")", "]", ">", ";", "<FIXE>" ]

[ "def", "VCMPEH", ":", "AHuI", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "HPR", ":", "$", "Sd", ",", "HPR", ":", "$", "Sm", ")", ",", "IIC_fpCMP16", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "[", "]", ">", ";", "<BUGE>", "def", "VCMPD", ":", "ADuI", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "DPR", ":", "$", "Dd", ",", "DPR", ":", "$", "Dm", ")", "," ]

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

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

[ ")", "return", "false", ";" ]

[ "if", "(", "I", "->", "isDebugValue", "(", ")", "||", "MemOps", ".", "count", "(", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "isCall", "(", ")", "||", "I", "->", "isTerminator", "(", ")", "||", "I", "->", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "isLd", "&&", "I", "->", "mayStore", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isLd", ")", "{", "if", "(", "I", "->", "mayLoad", "(", ")", ")", "return", "false", ";", "if", "(", "I", "->", "mayStore", "(", ")", ")", "return", "false", ";", "}", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "NumOps", "=", "I", "->", "getNumOperands", "(", ")", ";", "j", "!=", "NumOps", ";", "++", "j", ")", "{", "MachineOperand", "&", "MO", "=", "I", "->", "getOperand", "(", "j", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MO", ".", "isDef", "(", ")", "&&", "TRI", "->", "regsOverlap", "(", "Reg", ",", "Base", ")" ]

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

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

[ "emit_insn", "(", "gen_blockage", "(", ")", ")", ";" ]

[ "rtx", "div_table_rtx", "=", "gen_rtx_SYMBOL_REF", "(", "QImode", ",", "<STR_LIT>", "_divsi3_table", "<STR_LIT>", ")", ";", "rtx", "mem_rtx", ";", "rtx", "ret", ";", "rtx_insn", "*", "jump", ",", "*", "cjump", ",", "*", "insn", ";", "insn", "=", "emit_insn", "(", "gen_iorsi3", "(", "regt1", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "cjump", "=", "emit_jump_insn_after", "(", "gen_cbranchsi4", "(", "gen_rtx_GTU", "(", "SImode", ",", "regt1", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ",", "regt1", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "div_label", ")", ",", "insn", ")", ";", "LABEL_NUSES", "(", "div_label", ")", "=", "<NUM_LIT>", ";", "JUMP_LABEL", "(", "cjump", ")", "=", "div_label", ";", "emit_insn", "(", "gen_rtx_CLOBBER", "(", "SImode", ",", "reg18", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3_bshift", "(", "regt1", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "regt1", ",", "regt1", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "mem_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "regt1", ",", "div_table_rtx", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_movqi", "(", "regqi", ",", "mem_rtx", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_movsi", "(", "operands", "[", "<NUM_LIT>", "]", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "regqi", ",", "<NUM_LIT>", ")", ")", ")", ";", "jump", "=", "emit_jump_insn_after", "(", "gen_jump", "(", "div_end_label", ")", ",", "insn", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "div_end_label", ";", "LABEL_NUSES", "(", "div_end_label", ")", "=", "<NUM_LIT>", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "div_label", ")", ";", "ret", "=", "emit_library_call_value", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__divsi3", "<STR_LIT>", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "LCT_NORMAL", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "if", "(", "ret", "!=", "operands", "[", "<NUM_LIT>", "]", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "ret", ")", ";", "emit_label", "(", "div_end_label", ")", ";" ]

[ "const", "int", "_", "_", "c", ")", "{" ]

[ "vld1q_lane_p64", "(", "const", "poly64_t", "*", "_", "_", "a", ",", "poly64x2_t", "_", "_", "b", "," ]

[ "MI", ";" ]

[ "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "BundleMI", "=", "MI", ";", "continue", ";", "}", "if", "(", "MI", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "LiveCPSR", "=", "UpdateCPSRUse", "(", "*", "MI", ",", "LiveCPSR", ")", ";", "bool", "NextInSameBundle", "=", "NextMII", "!=", "E", "&&", "NextMII", "->", "isBundledWithPred", "(", ")", ";", "if", "(", "ReduceMI", "(", "MBB", ",", "MI", ",", "LiveCPSR", ",", "IsSelfLoop", ",", "SkipPrologueEpilogue", ")", ")", "{", "Modified", "=", "true", ";", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "std", "::", "prev", "(", "NextMII", ")", ";", "MI", "=", "&", "*", "I", ";", "if", "(", "NextInSameBundle", "&&", "!", "NextMII", "->", "isBundledWithPred", "(", ")", ")", "NextMII", "->", "bundleWithPred", "(", ")", ";", "}", "if", "(", "BundleMI", "&&", "!", "NextInSameBundle", "&&", "MI", "->", "isInsideBundle", "(", ")", ")", "{", "if", "(", "BundleMI", "->", "killsRegister", "(", "ARM", "::", "CPSR", ",", "nullptr", ")", ")", "LiveCPSR", "=", "false", ";", "MachineOperand", "*", "MO", "=", "BundleMI", "->", "findRegisterDefOperand", "(", "ARM", "::", "CPSR", ",", "nullptr", ")", ";", "if", "(", "MO", "&&", "!", "MO", "->", "isDead", "(", ")", ")", "LiveCPSR", "=", "true", ";", "MO", "=", "BundleMI", "->", "findRegisterUseOperand", "(", "ARM", "::", "CPSR", ",", "nullptr", ")", ";", "if", "(", "MO", "&&", "!", "MO", "->", "isKill", "(", ")", ")", "LiveCPSR", "=", "true", ";", "}", "bool", "DefCPSR", "=", "false", ";", "LiveCPSR", "=", "UpdateCPSRDef", "(", "*", "MI", ",", "LiveCPSR", ",", "DefCPSR", ")", ";", "if", "(", "MI", "->", "isCall", "(", ")", ")", "{", "CPSRDef", "=", "nullptr", ";", "HighLatencyCPSR", "=", "false", ";", "IsSelfLoop", "=", "false", ";", "}", "else", "if", "(", "DefCPSR", ")", "{", "CPSRDef", "=" ]

[ "&", "MF", ")", "const", "{" ]

[ "bool", "LC3RegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction" ]

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

[ ".", "setIsKill", "(", ")", ";" ]

[ "const", "unsigned", "t2SUB", "=", "ToSP", "?", "ARM", "::", "t2SUBspImm", ":", "ARM", "::", "t2SUBri", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "ImmVal", ")", ")", "NewUseOpc", "=", "UseOpc", "==", "ARM", "::", "t2ADDrr", "?", "t2ADD", ":", "t2SUB", ";", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "-", "ImmVal", ")", ")", "{", "ImmVal", "=", "-", "ImmVal", ";", "NewUseOpc", "=", "UseOpc", "==", "ARM", "::", "t2ADDrr", "?", "t2SUB", ":", "t2ADD", ";", "}", "else", "return", "false", ";", "SOImmValV1", "=", "(", "uint32_t", ")", "<STR_LIT>", "::", "<STR_LIT>", "(", "ImmVal", ")", ";", "SOImmValV2", "=", "(", "uint32_t", ")", "<STR_LIT>", "::", "<STR_LIT>", "(", "ImmVal", ")", ";", "break", ";", "}", "case", "ARM", "::", "t2ORRrr", ":", "case", "ARM", "::", "t2EORrr", ":", "if", "(", "!", "<STR_LIT>", "::", "<STR_LIT>", "(", "ImmVal", ")", ")", "return", "false", ";", "SOImmValV1", "=", "(", "uint32_t", ")", "<STR_LIT>", "::", "<STR_LIT>", "(", "ImmVal", ")", ";", "SOImmValV2", "=", "(", "uint32_t", ")", "<STR_LIT>", "::", "<STR_LIT>", "(", "ImmVal", ")", ";", "switch", "(", "UseOpc", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "t2ORRrr", ":", "NewUseOpc", "=", "ARM", "::", "t2ORRri", ";", "break", ";", "case", "ARM", "::", "t2EORrr", ":", "NewUseOpc", "=", "ARM", "::", "t2EORri", ";", "break", ";", "}", "break", ";", "}", "}", "}", "unsigned", "OpIdx", "=", "Commute", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "Register", "Reg1", "=", "UseMI", ".", "getOperand", "(", "OpIdx", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "UseMI", ".", "getOperand", "(", "OpIdx", ")", ".", "isKill", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "MRI", "->", "getRegClass", "(", "Reg", ")", ";", "Register", "NewReg", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "NewUseOpc", ")", ",", "NewReg", ")", ".", "addReg", "(", "Reg1", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "SOImmValV1", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "condCodeOp", "(", ")", ")", ";", "UseMI", ".", "setDesc", "(", "get", "(", "NewUseOpc", ")", ")", ";", "UseMI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "NewReg", ")", ";", "UseMI", ".", "getOperand", "(", "<NUM_LIT>", ")" ]

[ "bool", "SystemZMCAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "for", "(", "uint64_t", "I", "=", "<NUM_LIT>", ";", "I", "!=", "Count", ";", "++", "I", ")", "OW", "->", "Write8", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

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

[ "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float", ":", "V2DF" ]

[ ":" ]

[ "case", "ISD", "::", "SHL", ":", "if", "(", "Op", ".", "getNode", "(", ")", "->", "getFlags", "(", ")", ".", "hasNoSignedWrap", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "NeedOF", "=", "true", ";", "break", ";", "}", "break", ";", "}", "}", "if", "(", "Op", ".", "getResNo", "(", ")", "!=", "<NUM_LIT>", "||", "NeedOF", "||", "NeedCF", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "Op", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "}", "unsigned", "Opcode", "=", "<NUM_LIT>", ";", "unsigned", "NumOperands", "=", "<NUM_LIT>", ";", "SDValue", "ArithOp", "=", "Op", ";", "switch", "(", "ArithOp", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "if", "(", "!", "hasNonFlagsUse", "(", "Op", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "if", "(", "!", "isProfitableToUseFlagOp", "(", "Op", ")", ")", "break", ";", "switch", "(", "ArithOp", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unexpected operator!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ADD", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SUB", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "XOR", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "AND", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "NumOperands", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>" ]

[ "(", "Src", ".", "getReg", "(", ")", ",", "*", "SrcRC", ",", "*", "MRI", ")", ";" ]

[ "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "NewOpc", ")", ")", ";", "MI", ".", "removeOperand", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "*", "MF", ",", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "EXEC", ",", "false", ",", "true", ")", ")", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "Src", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "MRI", "->", "getType", "(", "Dst", ".", "getReg", "(", ")", ")", "==", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", "return", "false", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "TRI", ".", "getConstrainedRegClassForOperand", "(", "Dst", ",", "*", "MRI", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "TRI", ".", "getConstrainedRegClassForOperand", "(", "Src", ",", "*", "MRI", ")", ";", "if", "(", "!", "DstRC", "||", "DstRC", "!=", "SrcRC", ")", "return", "false", ";", "return", "RBI", ".", "constrainGenericRegister", "(", "Dst", ".", "getReg", "(", ")", ",", "*", "DstRC", ",", "*", "MRI", ")", "&&", "RBI", ".", "constrainGenericRegister" ]

[ "SDValue", "Cmp", "=", "getVFPCmp", "(", "LHS", ",", "RHS", ",", "DAG", ",", "dl", ")", ";" ]

[ "}", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "(", "TrueVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", "||", "TrueVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", ")", ")", "{", "<STR_LIT>", "::", "<STR_LIT>", "CondCode", "=", "IntCCToARMCC", "(", "CC", ")", ";", "if", "(", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "CC", "=", "ISD", "::", "getSetCCInverse", "(", "CC", ",", "true", ")", ";", "std", "::", "swap", "(", "TrueVal", ",", "FalseVal", ")", ";", "}", "}", "SDValue", "ARMcc", ";", "SDValue", "CCR", "=", "DAG", ".", "getRegister", "(", "ARM", "::", "CPSR", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Cmp", "=", "getARMCmp", "(", "LHS", ",", "RHS", ",", "CC", ",", "ARMcc", ",", "DAG", ",", "dl", ")", ";", "return", "getCMOV", "(", "dl", ",", "VT", ",", "FalseVal", ",", "TrueVal", ",", "ARMcc", ",", "CCR", ",", "Cmp", ",", "DAG", ")", ";", "}", "<STR_LIT>", "::", "<STR_LIT>", "CondCode", ",", "CondCode2", ";", "FPCCToARMCC", "(", "CC", ",", "CondCode", ",", "CondCode2", ")", ";", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "(", "TrueVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", "||", "TrueVal", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", ")", ")", "{", "bool", "swpCmpOps", "=", "false", ";", "bool", "swpVselOps", "=", "false", ";", "checkVSELConstraints", "(", "CC", ",", "CondCode", ",", "swpCmpOps", ",", "swpVselOps", ")", ";", "if", "(", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "CondCode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "swpCmpOps", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "if", "(", "swpVselOps", ")", "std", "::", "swap", "(", "TrueVal", ",", "FalseVal", ")", ";", "}", "}", "SDValue", "ARMcc", "=", "DAG", ".", "getConstant", "(", "CondCode", ",", "dl", ",", "MVT", "::", "i32", ")", ";" ]

[ ",", "Dst0", ")", ")", ";" ]

[ "if", "(", "Dst0", "==", "<NUM_LIT>", ")", "Rv", "(", "StackFixup", "::", "xchgTop", "(", "i", ")", ")", ";", "else", "if", "(", "i", "==", "<NUM_LIT>", ")", "Rv", "(", "StackFixup", "::", "xchgTop", "(", "Dst0", ")", ")", ";", "else", "Rv", "(", "StackFixup", "::", "xchg", "(", "i" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_castpd_si512", "(", "_", "_", "m512d", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512i", ")", "(", "_", "_", "A", ")", ";" ]

[ "Dest", ",", "EndDest", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Dest", ".", "getValueType", "(", ")", ",", "MVT", "::", "Other", ")", ";", "SDValue", "EndDest", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTs", ",", "Chain", ",", "Dest", ",", "Src", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "std", "::", "make_pair", "(", "isStpcpy", "?", "EndDest", ":" ]

[ ";" ]

[ "unsigned", "Register", "=", "GPR32DecoderTable", "[", "RegNo", "]", ";", "if", "(", "Register", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Register", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Register", ")", ")", ";", "return", "Success" ]

[ "<FIXS>", "let", "isCall", "=", "<NUM_LIT>", "indef", "JMPLrr", ":", "F3_1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "<FIXE>" ]

[ "}", "<BUGS>", "def", "JMPLrr", ":", "F3_1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "def", "JMPLri", ":", "F3_2", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "<BUGE>", "def", "WRrr", ":", "F3_1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "def", "WRri", ":", "F3_2", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ "static", "void", "find_constant_pool_ref", "(", "rtx", "x", ",", "rtx", "*", "ref", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "==", "UNSPEC_LTREL_BASE", ")", "return", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "==", "UNSPECV_POOL_ENTRY", ")", "return", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "==", "UNSPEC_LTREF", ")", "{", "rtx", "sym", "=", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "sym", ")", ")", ";", "if", "(", "*", "ref", "==", "NULL_RTX", ")", "*", "ref", "=", "sym", ";", "else", "gcc_assert", "(", "*", "ref", "==", "sym", ")", ";", "return", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'", "e", "'", ")", "{", "find_constant_pool_ref", "(", "XEXP", "(", "x", ",", "i", ")", ",", "ref", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "{", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "<", "XVECLEN", "(", "x", ",", "i", ")", ";", "j", "++", ")", "find_constant_pool_ref", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "ref", ")", ";", "}", "}", "}" ]

[ "Find", "an", "annotated", "literal", "pool", "symbol", "referenced", "in", "RTX", "X", ",", "and", "store", "it", "at", "REF", ".", "Will", "abort", "if", "X", "contains", "references", "to", "more", "than", "one", "such", "pool", "symbol", ";", "multiple", "references", "to", "the", "same", "symbol", "are", "allowed", ",", "however", ".", "The", "rtx", "pointed", "to", "by", "REF", "must", "be", "initialized", "to", "NULL_RTX", "by", "the", "caller", "before", "calling", "this", "routine", "." ]

[ "<FIXS>", "if", "(", "!", "integer_zerop", "(", "arg0", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "QImode", ",", "convert_to_mode", "(", "QImode", ",", "op1", ",", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "arg3", "=", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ";", "op1", "=", "expand_normal", "(", "arg0", ")", ";", "<BUGS>", "op1", "=", "copy_to_mode_reg", "(", "QImode", ",", "convert_to_mode", "(", "QImode", ",", "op1", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "op2", "=", "expand_normal", "(", "arg1", ")", ";", "if", "(", "!", "register_operand", "(", "op2", ",", "mode0", ")", ")" ]

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

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

[ "}" ]

[ "MCInstrInfo", "*", "X", "=", "new", "MCInstrInfo", "(", ")", ";", "InitBPFMCInstrInfo", "(", "X", ")", ";", "return", "X", ";" ]

[ ")", ";" ]

[ "if", "(", "S", ".", "getTargetStreamer", "(", ")", "==", "nullptr", ")", "new", "AArch64TargetStreamer", "(", "S", ")", ";", "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")" ]

[ "}" ]

[ "SH", "=", "<NUM_LIT>", "-", "Imm", ";", "}", "}", "if", "(", "Val", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "isInt32Immediate", "(", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "Imm", ")", "&&", "Imm", "<=", "MB", ")", "{", "assert", "(", "Imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "Illegal shift amount", "<STR_LIT>", ")", ";", "Val", "=", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SH", "=", "<NUM_LIT>", "-", "Imm", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Val", ",", "getI32Imm", "(", "SH", ",", "dl", ")", ",", "getI32Imm", "(", "MB", ",", "dl", ")", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "PPC", "::", "RLDICL", ",", "MVT", "::", "i64", ",", "Ops", ")", ";", "return", "true", ";" ]

[ "}" ]

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

[ "printU4ImmOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";" ]

[ "void", "AMDGPUInstPrinter", "::", "printRowMask", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "O", "<<", "<STR_LIT>", " row_mask:", "<STR_LIT>", ";" ]

[ "}" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "LL", ".", "size", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", "<<", "PrintIFR", "(", "LL", "[", "i", "]", ".", "first", ",", "HRI", ")", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "PrintRegSet", "(", "LL", "[", "i", "]", ".", "second", ",", "HRI", ")", "<<", "'", "\\n", "'", ";", "}" ]

[ "<FIXS>", "rtx", "addr", ",", "libfuncif", "(", "TARGET_SYNC_LIBCALLS", ")", "<FIXE>", "<FIXS>", "addr", "=", "convert_memory_address", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "libfunc", "=", "optab_libfunc", "(", "sync_lock_test_and_set_optab", ",", "QImode", ")", "emit_library_call", "(", "libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "addr", ",", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "QImode", ")", "DONE", "}", "if", "(", "TARGET_ATOMIC_LIBCALLS", ")", "{", "addr", "=", "convert_memory_address", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "libfunc", "=", "init_one_libfunc", "(", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "<BUGS>", "if", "(", "TARGET_SYNC_LIBCALL", ")", "<BUGE>", "{", "<BUGS>", "rtx", "libfunc", "=", "optab_libfunc", "(", "sync_lock_test_and_set_optab", ",", "QImode", ")", "rtx", "addr", "=", "convert_memory_address", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "<BUGE>", "emit_library_call", "(", "libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "addr", ",", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "QImode", ")", "DONE", "}", "FAIL", "}", ")", "<BUGS>", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "MemOpChains2", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Source", ",", "FIN", ",", "NULL", ",", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "Flags", ",", "DAG", ")", ")", ";", "}", "else", "{", "<BUGS>", "MemOpChains2", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Source", ",", "FIN", ",", "&", "PseudoSourceValue", "::", "FPRel", ",", "FI", ")", ")", ";", "<BUGE>", "}", "}", "}" ]

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

[ "Info", "->", "isPSInputAllocated", "(", "PSInputNum", ")", ")", "{" ]

[ "CCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "if", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_KERNEL", ")", "{", "allocateHSAUserSGPRs", "(", "CCInfo", ",", "MIRBuilder", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "const", "unsigned", "KernArgBaseAlign", "=", "<NUM_LIT>", ";", "const", "unsigned", "BaseOffset", "=", "Subtarget", "->", "getExplicitKernelArgOffset", "(", "F", ")", ";", "uint64_t", "ExplicitArgOffset", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "unsigned", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "ArgTy", ")", ";", "if", "(", "AllocSize", "==", "<NUM_LIT>", ")", "continue", ";", "unsigned", "ABIAlign", "=", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "uint64_t", "ArgOffset", "=", "alignTo", "(", "ExplicitArgOffset", ",", "ABIAlign", ")", "+", "BaseOffset", ";", "ExplicitArgOffset", "=", "alignTo", "(", "ExplicitArgOffset", ",", "ABIAlign", ")", "+", "AllocSize", ";", "ArrayRef", "<", "Register", ">", "OrigArgRegs", "=", "VRegs", "[", "i", "]", ";", "Register", "ArgReg", "=", "OrigArgRegs", ".", "size", "(", ")", "==", "<NUM_LIT>", "?", "OrigArgRegs", "[", "<NUM_LIT>", "]", ":", "MRI", ".", "createGenericVirtualRegister", "(", "getLLTForType", "(", "*", "ArgTy", ",", "DL", ")", ")", ";", "unsigned", "Align", "=", "MinAlign", "(", "KernArgBaseAlign", ",", "ArgOffset", ")", ";", "ArgOffset", "=", "alignTo", "(", "ArgOffset", ",", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ")", ";", "lowerParameter", "(", "MIRBuilder", ",", "ArgTy", ",", "ArgOffset", ",", "Align", ",", "ArgReg", ")", ";", "if", "(", "OrigArgRegs", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "unpackRegs", "(", "OrigArgRegs", ",", "ArgReg", ",", "ArgTy", ",", "MIRBuilder", ")", ";", "++", "i", ";", "}", "allocateSpecialEntryInputVGPRs", "(", "CCInfo", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "allocateSystemSGPRs", "(", "CCInfo", ",", "MF", ",", "*", "Info", ",", "F", ".", "getCallingConv", "(", ")", ",", "IsShader", ")", ";", "return", "true", ";", "}", "if", "(", "Info", "->", "hasImplicitBufferPtr", "(", ")", ")", "{", "unsigned", "ImplicitBufferPtrReg", "=", "Info", "->", "addImplicitBufferPtr", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "ImplicitBufferPtrReg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "ImplicitBufferPtrReg", ")", ";", "}", "unsigned", "NumArgs", "=", "F", ".", "arg_size", "(", ")", ";", "Function", "::", "const_arg_iterator", "CurOrigArg", "=", "F", ".", "arg_begin", "(", ")", ";", "const", "AMDGPUTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AMDGPUTargetLowering", ">", "(", ")", ";", "unsigned", "PSInputNum", "=", "<NUM_LIT>", ";", "BitVector", "Skipped", "(", "NumArgs", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumArgs", ";", "++", "i", ",", "++", "CurOrigArg", ")", "{", "EVT", "ValEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "CurOrigArg", "->", "getType", "(", ")", ")", ";", "ISD", "::", "ArgFlagsTy", "Flags", ";", "assert", "(", "VRegs", "[", "i", "]", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Can't lower into more than one register", "<STR_LIT>", ")", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", "[", "<NUM_LIT>", "]", ",", "CurOrigArg", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "<NUM_LIT>", ",", "DL", ",", "F", ")", ";", "Flags", ".", "setOrigAlign", "(", "DL", ".", "getABITypeAlignment", "(", "CurOrigArg", "->", "getType", "(", ")", ")", ")", ";", "if", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", "&&", "!", "OrigArg", ".", "Flags", ".", "isInReg", "(", ")", "&&", "!", "OrigArg", ".", "Flags", ".", "isByVal", "(", ")", "&&", "PSInputNum", "<=", "<NUM_LIT>", ")", "{", "if", "(", "CurOrigArg", "->", "use_empty", "(", ")", "&&", "!" ]

[ "}" ]

[ "static", "void", "adjust_subreg_index", "(", "rtx", "op", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "code", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", "{", "unsigned", "int", "index", "=", "SUBREG_BYTE", "(", "op", ")", ";", "if", "(", "index", "<", "<NUM_LIT>", ")", "index", "+=", "<NUM_LIT>", ";", "else", "index", "-=", "<NUM_LIT>", ";", "SUBREG_BYTE", "(", "op", ")", "=", "index", ";" ]

[ "::", "SBC16aa", ";" ]

[ "unsigned", "Opc", ",", "Reg", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected opcode", "<STR_LIT>", ")", ";", "case", "Z80old", "::", "SExt8", ":", "Opc", "=", "Z80old", "::", "SBC8ar", ";", "Reg", "=", "Z80old", "::", "A", ";", "break", ";", "case", "Z80old", "::", "SExt16", ":", "Opc", "=", "Z80old" ]

[ "<FIXS>", "explicit", "AVRInstrInfo", "(", "AVRSubtarget", "&", "STI", ")", ";", "<FIXE>" ]

[ "class", "AVRInstrInfo", ":", "public", "AVRGenInstrInfo", "{", "public", ":", "<BUGS>", "explicit", "AVRInstrInfo", "(", ")", ";", "<BUGE>", "const", "AVRRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "const", "MCInstrDesc", "&", "getBrCond", "(", "<STR_LIT>", "::", "<STR_LIT>", "CC", ")", "const", ";" ]

[ "(", "N", ")", ",", "MVT", "::", "i32", ")", ";" ]

[ "static", "bool", "checkCVTFixedPointOperandWithFBits", "(", "SelectionDAG", "*", "CurDAG", ",", "SDValue", "N", ",", "SDValue", "&", "FixedPos", ",", "unsigned", "RegWidth", ",", "bool", "isReciprocal", ")", "{", "APFloat", "FVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "ConstantFPSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "N", ")", ")", "FVal", "=", "CN", "->", "getValueAPF", "(", ")", ";", "else", "if", "(", "LoadSDNode", "*", "LN", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "if", "(", "LN", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "!", "isa", "<", "ConstantPoolSDNode", ">", "(", "LN", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "false", ";", "ConstantPoolSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "LN", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "FVal", "=", "cast", "<", "ConstantFP", ">", "(", "CN", "->", "getConstVal", "(", ")", ")", "->", "getValueAPF", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "IsExact", ";", "if", "(", "isReciprocal", ")", "if", "(", "!", "FVal", ".", "getExactInverse", "(", "&", "FVal", ")", ")", "return", "false", ";", "APSInt", "IntVal", "(", "<NUM_LIT>", ",", "true", ")", ";", "FVal", ".", "convertToInteger", "(", "IntVal", ",", "APFloat", "::", "rmTowardZero", ",", "&", "IsExact", ")", ";", "if", "(", "!", "IsExact", "||", "!", "IntVal", ".", "isPowerOf2", "(", ")", ")", "return", "false", ";", "unsigned", "FBits", "=", "IntVal", ".", "logBase2", "(", ")", ";", "if", "(", "FBits", "==", "<NUM_LIT>", "||", "FBits", ">", "RegWidth", ")", "return", "false", ";", "FixedPos", "=", "CurDAG", "->", "getTargetConstant", "(", "FBits", ",", "SDLoc" ]

[ "(", "unspec", ":", "XF", "[", "(", "float_extend", ":", "XF", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "UNSPEC_SINCOS_SIN", ")", ")", "]" ]

[ "(", "unspec", ":", "XF", "[", "(", "float_extend", ":", "XF", "(", "match_operand", ":", "MODEF", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_SINCOS_COS", ")", ")", "(", "set", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "unspec", ":", "QI", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>" ]

[ "CMGEddi", ">", ";" ]

[ "def", ":", "Neon_Scalar2SameMisc_cmpz_D_V1_size_patterns", "<", "SETGE", "," ]

[ "(", "IMPLICIT_DEF", ")", ")", ",", "SPR", ":", "$", "src", ",", "ssub_0", ")", ",", "(", "i32", "<NUM_LIT>", ")", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4f32", "(", "NEONvdup", "(", "f32", "SPR", ":", "$", "src", ")", ")", ")", ",", "(", "v4f32", "(", "VDUPLN32q", "(", "INSERT_SUBREG", "(", "v2f32" ]

[ "bool", "MipsCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallingConv", "::", "ID", "CallConv", ",", "const", "MachineOperand", "&", "Callee", ",", "const", "ArgInfo", "&", "OrigRet", ",", "ArrayRef", "<", "ArgInfo", ">", "OrigArgs", ")", "const", "{", "if", "(", "CallConv", "!=", "CallingConv", "::", "C", ")", "return", "false", ";", "for", "(", "auto", "&", "Arg", ":", "OrigArgs", ")", "{", "if", "(", "!", "isSupportedType", "(", "Arg", ".", "Ty", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", "||", "Arg", ".", "Flags", ".", "isSRet", "(", ")", ")", "return", "false", ";", "}", "if", "(", "OrigRet", ".", "Reg", "&&", "!", "isSupportedType", "(", "OrigRet", ".", "Ty", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "const", "MipsTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "MipsABIInfo", "&", "ABI", "=", "TM", ".", "getABI", "(", ")", ";", "MachineInstrBuilder", "CallSeqStart", "=", "MIRBuilder", ".", "buildInstr", "(", "Mips", "::", "ADJCALLSTACKDOWN", ")", ";", "const", "bool", "IsCalleeGlobalPIC", "=", "Callee", ".", "isGlobal", "(", ")", "&&", "TM", ".", "isPositionIndependent", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Callee", ".", "isReg", "(", ")", "||", "IsCalleeGlobalPIC", "?", "Mips", "::", "JALRPseudo", ":", "Mips", "::", "JAL", ")", ";", "MIB", ".", "addDef", "(", "Mips", "::", "SP", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "IsCalleeGlobalPIC", ")", "{", "unsigned", "CalleeReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "MachineInstr", "*", "CalleeGlobalValue", "=", "MIRBuilder", ".", "buildGlobalValue", "(", "CalleeReg", ",", "Callee", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "Callee", ".", "getGlobal", "(", ")", "->", "hasLocalLinkage", "(", ")", ")", "CalleeGlobalValue", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setTargetFlags", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MIB", ".", "addUse", "(", "CalleeReg", ")", ";", "}", "else", "MIB", ".", "add", "(", "Callee", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "F", ".", "getCallingConv", "(", ")", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "FuncOrigArgs", ";", "FuncOrigArgs", ".", "reserve", "(", "OrigArgs", ".", "size", "(", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OrigArgIndices", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "OrigArgs", ")", "{", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "Arg", ".", "Ty", ";", "FuncOrigArgs", ".", "push_back", "(", "Entry", ")", ";", "splitToValueTypes", "(", "Arg", ",", "i", ",", "ArgInfos", ",", "OrigArgIndices", ")", ";", "++", "i", ";", "}", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "ArgInfos", ",", "OrigArgIndices", ",", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "ABI", ".", "GetCalleeAllocdArgSizeInBytes", "(", "CallConv", ")", ",", "<NUM_LIT>", ")", ";", "const", "char", "*", "Call", "=", "Callee", ".", "isSymbol", "(", ")", "?", "Callee", ".", "getSymbolName", "(", ")", ":", "nullptr", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "TLI", ".", "CCAssignFnForCall", "(", ")", ",", "FuncOrigArgs", ",", "Call", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Outs", ")", ";", "OutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "MIB", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "{", "return", "false", ";", "}", "unsigned", "NextStackOffset", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "unsigned", "StackAlignment", "=", "TFL", "->", "getStackAlignment", "(", ")", ";", "NextStackOffset", "=", "alignTo", "(", "NextStackOffset", ",", "StackAlignment", ")", ";", "CallSeqStart", ".", "addImm", "(", "NextStackOffset", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "IsCalleeGlobalPIC", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "Mips", "::", "GP", ",", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getGlobalBaseRegForGlobalISel", "(", ")", ")", ";", "MIB", ".", "addDef", "(", "Mips", "::", "GP", ",", "RegState", "::", "Implicit", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "MIB", "->", "getOpcode", "(", ")", "==", "Mips", "::", "JALRPseudo", ")", "{", "const", "MipsSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "(", ")", ")", ";", "MIB", ".", "constrainAllUses", "(", "MIRBuilder", ".", "getTII", "(", ")", ",", "*", "STI", ".", "getRegisterInfo", "(", ")", ",", "*", "STI", ".", "getRegBankInfo", "(", ")", ")", ";", "}", "if", "(", "OrigRet", ".", "Reg", ")", "{", "ArgInfos", ".", "clear", "(", ")", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OrigRetIndices", ";", "splitToValueTypes", "(", "OrigRet", ",", "<NUM_LIT>", ",", "ArgInfos", ",", "OrigRetIndices", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "<NUM_LIT>", ">", "Ins", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "ArgInfos", ",", "OrigRetIndices", ",", "Ins", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ",", "OrigRet", ".", "Ty", ",", "Call", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Ins", ")", ";", "CallReturnHandler", "Handler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "MIB", ")", ";", "if", "(", "!", "Handler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "buildInstr", "(", "Mips", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "NextStackOffset", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "<FIXS>", "tree", "fntype", "=", "rs6000_builtin_info", "[", "instance", "->", "bifid", "]", ".", "fntype", ";", "<FIXE>" ]

[ "if", "(", "rs6000_builtin_decl", "(", "instance", "->", "bifid", ",", "false", ")", "!=", "error_mark_node", "&&", "supported", ")", "{", "<BUGS>", "tree", "fntype", "=", "rs6000_builtin_info_x", "[", "instance", "->", "bifid", "]", ".", "fntype", ";", "<BUGE>", "tree", "ret_type", "=", "TREE_TYPE", "(", "instance", "->", "fntype", ")", ";", "return", "altivec_build_resolved_builtin", "(", "args", ",", "n", ",", "fntype", ",", "ret_type", "," ]

[ "<NUM_LIT>", ";" ]

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

[ "}", "]", ",", "logical_imm64_XFORM", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "def", "logical_imm64", ":", "Operand", "<", "i64", ">", ",", "IntImmLeaf", "<", "i64", ",", "[", "{", "return", "AArch64_AM", ":", ":", "isLogicalImmediate", "(", "Imm", ".", "getZExtValue", "(", ")", ",", "<NUM_LIT>", ")", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_castpd512_pd128", "(", "_", "_", "m512d", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "mm512_extractf32x4_ps", "(", "(", "_", "_", "m512", ")", "_", "_", "A", "," ]

[ "return", "val", ">=", "<NUM_LIT>", "&&", "val", "<", "<NUM_LIT>", ";" ]

[ "int", "thumb_legitimate_offset_p", "(", "enum", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "<NUM_LIT>", ":" ]

[ "true", ";" ]

[ "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return" ]

[ "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "trap_if", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_fmsub_ph", "(", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128h", ")", "_", "_", "builtin_ia32_vfmsubph128_mask", "(", "(", "_", "_", "v8hf", ")", "_", "_", "A", ",", "(", "_", "_", "v8hf", ")", "_", "_", "B", ",", "(", "_", "_", "v8hf", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "unsigned", "SelOp", "=", "AMDGPU", "::", "V_CNDMASK_B32_e32", ";" ]

[ "if", "(", "DstSize", "==", "<NUM_LIT>", "&&", "Pred", "==", "SCC_TRUE", ")", "{", "MachineInstr", "*", "Select", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_CSELECT_B64", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ";", "preserveCondRegFlags", "(", "Select", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "return", ";", "}", "static", "const", "int16_t", "Sub0_15", "[", "]", "=", "{", "AMDGPU", "::", "sub0", ",", "AMDGPU", "::", "sub1", ",", "AMDGPU", "::", "sub2", ",", "AMDGPU", "::", "sub3", ",", "AMDGPU", "::", "sub4", ",", "AMDGPU", "::", "sub5", ",", "AMDGPU", "::", "sub6", ",", "AMDGPU", "::", "sub7", ",", "AMDGPU", "::", "sub8", ",", "AMDGPU", "::", "sub9", ",", "AMDGPU", "::", "sub10", ",", "AMDGPU", "::", "sub11", ",", "AMDGPU", "::", "sub12", ",", "AMDGPU", "::", "sub13", ",", "AMDGPU", "::", "sub14", ",", "AMDGPU", "::", "sub15", ",", "}", ";", "static", "const", "int16_t", "Sub0_15_64", "[", "]", "=", "{", "AMDGPU", "::", "sub0_sub1", ",", "AMDGPU", "::", "sub2_sub3", ",", "AMDGPU", "::", "sub4_sub5", ",", "AMDGPU", "::", "sub6_sub7", ",", "AMDGPU", "::", "sub8_sub9", ",", "AMDGPU", "::", "sub10_sub11", ",", "AMDGPU", "::", "sub12_sub13", ",", "AMDGPU", "::", "sub14_sub15", ",", "}", ";" ]

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

[ "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "DL", ",", "Reg", ",", "VT", ")", ";" ]

[ "}", "}", "else", "{", "Splits", ".", "push_back", "(", "Arg", ")", ";", "}", "}", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "AMDGPU_PS", "&&", "(", "(", "Info", "->", "getPSInputAddr", "(", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "||", "(", "(", "Info", "->", "getPSInputAddr", "(", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "Info", "->", "isPSInputAllocated", "(", "<NUM_LIT>", ")", ")", ")", ")", "{", "CCInfo", ".", "AllocateReg", "(", "AMDGPU", "::", "VGPR0", ")", ";", "CCInfo", ".", "AllocateReg", "(", "AMDGPU", "::", "VGPR1", ")", ";", "Info", "->", "markPSInputAllocated", "(", "<NUM_LIT>", ")", ";", "Info", "->", "PSInputEna", "|=", "<NUM_LIT>", ";", "}", "if", "(", "!", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "assert", "(", "Info", "->", "hasWorkGroupIDX", "(", ")", "&&", "Info", "->", "hasWorkItemIDX", "(", ")", ")", ";", "}", "else", "{", "assert", "(", "!", "Info", "->", "hasDispatchPtr", "(", ")", "&&", "!", "Info", "->", "hasKernargSegmentPtr", "(", ")", "&&", "!", "Info", "->", "hasFlatScratchInit", "(", ")", "&&", "!", "Info", "->", "hasWorkGroupIDX", "(", ")", "&&", "!", "Info", "->", "hasWorkGroupIDY", "(", ")", "&&", "!", "Info", "->", "hasWorkGroupIDZ", "(", ")", "&&", "!", "Info", "->", "hasWorkGroupInfo", "(", ")", "&&", "!", "Info", "->", "hasWorkItemIDX", "(", ")", "&&", "!", "Info", "->", "hasWorkItemIDY", "(", ")", "&&", "!", "Info", "->", "hasWorkItemIDZ", "(", ")", ")", ";", "}", "if", "(", "Info", "->", "hasPrivateMemoryInputPtr", "(", ")", ")", "{", "unsigned", "PrivateMemoryPtrReg", "=", "Info", "->", "addPrivateMemoryPtr", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "PrivateMemoryPtrReg", ",", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "PrivateMemoryPtrReg", ")", ";", "}", "if", "(", "Info", "->", "hasPrivateSegmentBuffer", "(", ")", ")", "{", "unsigned", "PrivateSegmentBufferReg", "=", "Info", "->", "addPrivateSegmentBuffer", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "PrivateSegmentBufferReg", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "PrivateSegmentBufferReg", ")", ";", "}", "if", "(", "Info", "->", "hasDispatchPtr", "(", ")", ")", "{", "unsigned", "DispatchPtrReg", "=", "Info", "->", "addDispatchPtr", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "DispatchPtrReg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "DispatchPtrReg", ")", ";", "}", "if", "(", "Info", "->", "hasQueuePtr", "(", ")", ")", "{", "unsigned", "QueuePtrReg", "=", "Info", "->", "addQueuePtr", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "QueuePtrReg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "QueuePtrReg", ")", ";", "}", "if", "(", "Info", "->", "hasKernargSegmentPtr", "(", ")", ")", "{", "unsigned", "InputPtrReg", "=", "Info", "->", "addKernargSegmentPtr", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "InputPtrReg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "InputPtrReg", ")", ";", "}", "if", "(", "Info", "->", "hasDispatchID", "(", ")", ")", "{", "unsigned", "DispatchIDReg", "=", "Info", "->", "addDispatchID", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "DispatchIDReg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "DispatchIDReg", ")", ";", "}", "if", "(", "Info", "->", "hasFlatScratchInit", "(", ")", ")", "{", "unsigned", "FlatScratchInitReg", "=", "Info", "->", "addFlatScratchInit", "(", "*", "TRI", ")", ";", "MF", ".", "addLiveIn", "(", "FlatScratchInitReg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "CCInfo", ".", "AllocateReg", "(", "FlatScratchInitReg", ")", ";", "}", "if", "(", "!", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "else", "AnalyzeFormalArguments", "(", "CCInfo", ",", "Splits", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Chains", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Ins", ".", "size", "(", ")", ",", "ArgIdx", "=", "<NUM_LIT>", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "ISD", "::", "InputArg", "&", "Arg", "=", "Ins", "[", "i", "]", ";", "if", "(", "Skipped", "[", "i", "]", ")", "{", "InVals", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "Arg", ".", "VT", ")", ")", ";", "continue", ";", "}", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "ArgIdx", "++", "]", ";", "MVT", "VT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "VA", ".", "isMemLoc", "(", ")", ")", "{", "VT", "=", "Ins", "[", "i", "]", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "const", "unsigned", "Offset", "=", "Subtarget", "->", "getExplicitKernelArgOffset", "(", "MF", ")", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "SDValue", "Arg", "=", "LowerParameter", "(", "DAG", ",", "VT", ",", "MemVT", ",", "DL", ",", "Chain", ",", "Offset", ",", "Ins", "[", "i", "]", ".", "Flags", ".", "isSExt", "(", ")", ",", "&", "Ins", "[", "i", "]", ")", ";", "Chains", ".", "push_back", "(", "Arg", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "auto", "*", "ParamTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "FType", "->", "getParamType", "(", "Ins", "[", "i", "]", ".", "getOrigArgIndex", "(", ")", ")", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "SISubtarget", "::", "SOUTHERN_ISLANDS", "&&", "ParamTy", "&&", "ParamTy", "->", "getAddressSpace", "(", ")", "==", "AMDGPUASI", ".", "LOCAL_ADDRESS", ")", "{", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "Arg", ".", "getValueType", "(", ")", ",", "Arg", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i16", ")", ")", ";", "}", "InVals", ".", "push_back", "(", "Arg", ")", ";", "Info", "->", "setABIArgOffset", "(", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Parameter must be in a register!", "<STR_LIT>", ")", ";", "unsigned", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "Reg", "=", "TRI", "->", "getMatchingSuperReg", "(", "Reg", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "Reg", "=", "MF", ".", "addLiveIn", "(", "Reg", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "SDValue", "Copy", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Copy", ")", ";", "continue", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ",", "VT", ")", ";", "Reg", "=", "MF", ".", "addLiveIn", "(", "Reg", ",", "RC", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", "," ]

[ "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "idx", "]", ".", "predicate", ")", "(", "op", "[", "arg_count", "]", ",", "insn_op", "->", "mode", ")", ")", "op", "[", "arg_count", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arg_count", "]", ")", ";" ]

[ "op", "[", "arg_count", "]", "=", "expand_normal", "(", "arg", ")", ";", "if", "(", "code", "==", "SPARC_BUILTIN_LDFSR", "||", "code", "==", "SPARC_BUILTIN_STFSR", ")", "{", "if", "(", "!", "address_operand", "(", "op", "[", "arg_count", "]", ",", "SImode", ")", ")", "{", "op", "[", "arg_count", "]", "=", "convert_memory_address", "(", "Pmode", ",", "op", "[", "arg_count", "]", ")", ";", "op", "[", "arg_count", "]", "=", "copy_addr_to_reg", "(", "op", "[", "arg_count", "]", ")", ";", "}", "op", "[", "arg_count", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "op", "[", "arg_count", "]", ")", ";", "}", "else", "if", "(", "insn_op", "->", "mode", "==", "V1DImode", "&&", "GET_MODE", "(", "op", "[", "arg_count", "]", ")", "==", "DImode", ")", "op", "[", "arg_count", "]", "=", "gen_lowpart", "(", "V1DImode", ",", "op", "[", "arg_count", "]", ")", ";", "else", "if", "(", "insn_op", "->", "mode", "==", "V1SImode", "&&", "GET_MODE", "(", "op", "[", "arg_count", "]", ")", "==", "SImode", ")", "op", "[", "arg_count", "]", "=", "gen_lowpart", "(", "V1SImode", ",", "op", "[", "arg_count", "]", ")", ";" ]

[ "return", "FALSE", ";" ]

[ "static", "bool", "nds32_ict_const_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "return", "nds32_indirect_call_referenced_p", "(", "x", ")", ";", "}" ]

[ "SDValue", "ARMTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDC", ":", "return", "PerformADDCCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBFICombine", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVMOVRRDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVMOVDRRCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "PerformInsertEltCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVDUPLANECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "PerformVCVTCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "PerformVDIVCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "PerformExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "PerformLOADCombine", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVLDCombine", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformARMBUILD_VECTORCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vld2lane", ":", "case", "Intrinsic", "::", "arm_neon_vld3lane", ":", "case", "Intrinsic", "::", "arm_neon_vld4lane", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "return", "PerformVLDCombine", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "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", "." ]

[ "}" ]

[ "const", "char", "*", "name", "=", "XSTR", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "VTABLE_NAME_P", "(", "name", ")", ")", "{", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "name", ")", ";" ]

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

[ "class", "BaseOneOperandFPComparison", "<", "bit", "signalAllNans", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pat", ">", ",", "Sched", "<", "[", "WriteFCmp", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

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

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

[ "}" ]

[ "const", "auto", "&", "TFI", "=", "static_cast", "<", "const", "MOSFrameLowering", "&", ">", "(", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "if", "(", "TFI", ".", "isISR", "(", "MF", ")", ")", "MIRBuilder", ".", "buildInstr", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SmallVector", "<", "ArgInfo", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ",", "Idx", "}", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ")", ";", "++", "Idx", ";", "}", "MOSIncomingArgsHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ")", ";", "MOSValueAssigner", "Assigner", "(", "true", ",", "MRI", ",", "MF", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "Handler", ",", "Assigner", ",", "SplitArgs", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "auto", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "MOSFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "Assigner", ".", "StackOffset", ",", "true", ")", ")", ";", "}", "return", "true", ";" ]

[ "Expr", ")", ";" ]

[ "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "const", "MCExpr", "*", "Expr", "=", "getImm", "(", ")", ";", "addExpr", "(", "Inst", "," ]

[ "static", "rtx", "loongarch_allocate_fcc", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ",", "count", ";", "gcc_assert", "(", "TARGET_HARD_FLOAT", ")", ";", "if", "(", "mode", "==", "FCCmode", ")", "count", "=", "<NUM_LIT>", ";", "else", "gcc_unreachable", "(", ")", ";", "cfun", "->", "machine", "->", "next_fcc", "+=", "-", "cfun", "->", "machine", "->", "next_fcc", "&", "(", "count", "-", "<NUM_LIT>", ")", ";", "if", "(", "cfun", "->", "machine", "->", "next_fcc", ">", "FCC_REG_LAST", "-", "FCC_REG_FIRST", ")", "cfun", "->", "machine", "->", "next_fcc", "=", "<NUM_LIT>", ";", "regno", "=", "FCC_REG_FIRST", "+", "cfun", "->", "machine", "->", "next_fcc", ";", "cfun", "->", "machine", "->", "next_fcc", "+=", "count", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}" ]

[ "Allocate", "a", "floating-point", "condition-code", "register", "of", "mode", "MODE", "." ]

[ "]" ]

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

[ "}" ]

[ "static", "LegalizeMutation", "oneMoreElement", "(", "unsigned", "TypeIdx", ")", "{", "return", "[", "=", "]", "(", "const", "LegalityQuery", "&", "Query", ")", "{", "const", "LLT", "Ty", "=", "Query", ".", "Types", "[", "TypeIdx", "]", ";", "const", "LLT", "EltTy", "=", "Ty", ".", "getElementType", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TypeIdx", ",", "LLT", "::", "vector", "(", "Ty", ".", "getNumElements", "(", ")", "+", "<NUM_LIT>", ",", "EltTy", ")", ")", ";", "}", ";" ]

[ "::", "FP_TO_SINT", ";" ]

[ "uint32_t", "IntBits", "=", "IntTy", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumLanes", "=", "Op", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "FloatBits", "!=", "<NUM_LIT>", "||", "IntBits", ">", "<NUM_LIT>", "||", "(", "NumLanes", "!=", "<NUM_LIT>", "&&", "NumLanes", "!=", "<NUM_LIT>", ")", ")", "{", "return", "SDValue", "(", ")", ";", "}", "BitVector", "UndefElements", ";", "BuildVectorSDNode", "*", "BV", "=", "cast", "<", "BuildVectorSDNode", ">", "(", "ConstVec", ")", ";", "int32_t", "C", "=", "BV", "->", "getConstantFPSplatPow2ToLog2Int", "(", "&", "UndefElements", ",", "<NUM_LIT>", ")", ";", "if", "(", "C", "==", "-", "<NUM_LIT>", "||", "C", "==", "<NUM_LIT>", "||", "C", ">", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "bool", "isSigned", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD" ]

[ "}", ")" ]

[ "{", "mips_expand_vcondv2sf", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "LE", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

[ "ExtTy", ")", ";" ]

[ "EVT", "VT", "=", "Cmp", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "unsigned", "Log2b", "=", "Log2_32", "(", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "Clz", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CTLZ", ",", "dl", ",", "VT", ",", "Cmp", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Trunc", "=", "DAG", ".", "getZExtOrTrunc", "(", "Clz", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Scc", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i32", ",", "Trunc", ",", "DAG", ".", "getConstant", "(", "Log2b", ",", "dl", ",", "VT", ")", ")", ";", "return", "DAG", ".", "getZExtOrTrunc", "(", "Scc", ",", "dl", "," ]

[ "}" ]

[ "assert", "(", "PHI", ".", "isPHI", "(", ")", ")", ";", "return", "PHI", ".", "getOperand", "(", "Index", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "}" ]

[ "let", "isAuthenticated", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "M", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "W", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "let", "isExtentSigned", "=", "<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", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

[ "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "zero_extend", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")" ]

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

[ "(", "clobber", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "{", "gcc_assert", "(", "MEM_P", "(", "operands", "[" ]

[ "<STR_LIT>", ";" ]

[ "def", "ExtendOperand", ":", "AsmOperandClass", "{", "let", "Name", "=" ]

[ "=", "<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", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Constraints" ]

[ ")", "]" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashiftrt", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "Idx", "++", "*", "<NUM_LIT>", ")", ";" ]

[ "int", "CURegNum", "=", "getCompactUnwindRegNum", "(", "Reg", ")", ";", "if", "(", "CURegNum", "==", "-", "<NUM_LIT>", ")", "return", "~", "<NUM_LIT>", "U", ";", "RegEnc", "|=", "(", "CURegNum", "&", "<NUM_LIT>", ")", "<<", "(" ]

[ ")", ";" ]

[ "case", "X86", "::", "AVX1_SETALLONES", ":", "{", "unsigned", "Reg", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MIB", "->", "setDesc", "(", "get", "(", "X86", "::", "VCMPPSYrri", ")", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "AVX512_512_SETALLONES", ":", "{", "unsigned", "Reg", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MIB", "->", "setDesc", "(", "get", "(", "X86", "::", "VPTERNLOGDZrri", ")", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "AVX512_512_SEXT_MASK_32", ":", "case", "X86", "::", "AVX512_512_SEXT_MASK_64", ":", "{", "unsigned", "Reg", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "MaskReg", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "MaskState", "=", "getRegState", "(", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "Opc", "=", "(", "MI", ".", "getOpcode", "(", ")", "==", "X86", "::", "AVX512_512_SEXT_MASK_64", ")", "?", "X86", "::", "VPTERNLOGQZrrikz", ":", "X86", "::", "VPTERNLOGDZrrikz", ";", "MI", ".", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "MIB", "->", "setDesc", "(", "get", "(", "Opc", ")", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "MaskReg", ",", "MaskState", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "VMOVAPSZ128rm_NOVLX", ":", "return", "expandNOVLXLoad", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVAPSrm", ")", ",", "get", "(", "X86", "::", "VBROADCASTF32X4rm", ")", ",", "X86", "::", "sub_xmm", ")", ";", "case", "X86", "::", "VMOVUPSZ128rm_NOVLX", ":", "return", "expandNOVLXLoad", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVUPSrm", ")", ",", "get", "(", "X86", "::", "VBROADCASTF32X4rm", ")", ",", "X86", "::", "sub_xmm", ")", ";", "case", "X86", "::", "VMOVAPSZ256rm_NOVLX", ":", "return", "expandNOVLXLoad", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVAPSYrm", ")", ",", "get", "(", "X86", "::", "VBROADCASTF64X4rm", ")", ",", "X86", "::", "sub_ymm", ")", ";", "case", "X86", "::", "VMOVUPSZ256rm_NOVLX", ":", "return", "expandNOVLXLoad", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVUPSYrm", ")", ",", "get", "(", "X86", "::", "VBROADCASTF64X4rm", ")", ",", "X86", "::", "sub_ymm", ")", ";", "case", "X86", "::", "VMOVAPSZ128mr_NOVLX", ":", "return", "expandNOVLXStore", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVAPSmr", ")", ",", "get", "(", "X86", "::", "VEXTRACTF32x4Zmr", ")", ",", "X86", "::", "sub_xmm", ")", ";", "case", "X86", "::", "VMOVUPSZ128mr_NOVLX", ":", "return", "expandNOVLXStore", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVUPSmr", ")", ",", "get", "(", "X86", "::", "VEXTRACTF32x4Zmr", ")", ",", "X86", "::", "sub_xmm", ")", ";", "case", "X86", "::", "VMOVAPSZ256mr_NOVLX", ":", "return", "expandNOVLXStore", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVAPSYmr", ")", ",", "get", "(", "X86", "::", "VEXTRACTF64x4Zmr", ")", ",", "X86", "::", "sub_ymm", ")", ";", "case", "X86", "::", "VMOVUPSZ256mr_NOVLX", ":", "return", "expandNOVLXStore", "(", "MIB", ",", "&", "getRegisterInfo", "(", ")", ",", "get", "(", "X86", "::", "VMOVUPSYmr", ")", ",", "get", "(", "X86", "::", "VEXTRACTF64x4Zmr", ")", ",", "X86", "::", "sub_ymm", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", ".", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")" ]

[ "rtx", "pa_eh_return_handler_rtx", "(", "void", ")", "{", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_PLUS", "(", "word_mode", ",", "hard_frame_pointer_rtx", ",", "TARGET_64BIT", "?", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ":", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ";", "tmp", "=", "gen_rtx_MEM", "(", "word_mode", ",", "tmp", ")", ";", "tmp", "->", "volatil", "=", "<NUM_LIT>", ";", "return", "tmp", ";", "}" ]

[ "Implement", "EH_RETURN_HANDLER_RTX", ".", "The", "MEM", "needs", "to", "be", "volatile", "to", "prevent", "it", "from", "being", "deleted", "." ]

[ "<FIXS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "Hi", ",", "Lo", ")", ";", "<FIXE>", "<FIXS>", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "<FIXE>", "<FIXS>", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "Hi", ",", "Lo", ")", ";", "<FIXE>", "<FIXS>", "return", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Lo", ",", "NULL", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "!", "TM", ".", "getSubtarget", "PPCSubtarget", ">", "(", ")", ".", "isDarwin", "(", ")", ")", "{", "<BUGS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "PtrVT", ",", "Hi", ",", "Lo", ")", ";", "<BUGE>", "}", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "<BUGS>", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "PtrVT", ",", "<BUGE>", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "PtrVT", ")", ",", "Hi", ")", ";", "}", "<BUGS>", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "PtrVT", ",", "Hi", ",", "Lo", ")", ";", "<BUGE>", "if", "(", "!", "TM", ".", "getSubtarget", "PPCSubtarget", ">", "(", ")", ".", "hasLazyResolverStub", "(", "GV", ")", ")", "return", "Lo", ";", "<BUGS>", "return", "DAG", ".", "getLoad", "(", "PtrVT", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Lo", ",", "NULL", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "SDValue", "PPCTargetLowering", "::", "LowerSETCC", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{" ]

[ "<FIXS>", "so", "we", "need", "to", "use", "relational", "tests", "against", "overflow", "<FIXE>" ]

[ "return", "CCGCmode", ";", "case", "GT", ":", "case", "LE", ":" ]

[ "?", "xcoff_private_rodata_section_name", ":", "xcoff_read_only_section_name", ",", "XCOFF_CSECT_DEFAULT_ALIGNMENT_STR", ")", ";" ]

[ "static", "void", "rs6000_xcoff_output_readonly_section_asm_op", "(", "const", "char", "*", "directive", ")", "{", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.csect %s[RO],%s\\n", "<STR_LIT>", ",", "directive" ]

[ "}" ]

[ "let", "ParserMatchClass", "=", "VecListThreeDWordIndexAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd", ",", "i32imm", ":", "$", "idx", ")", ";" ]

[ "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "emit_push_byte", "(", "treg", ",", "frame_related_p", ")", ";", "if", "(", "clr_p", ")", "{", "insn", "=", "emit_move_insn", "(", "sfr", ",", "const0_rtx", ")", ";" ]

[ "}" ]

[ "}", "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "hreset", "(", "unsigned", "int", "_", "_", "EAX", ")", "{", "_", "_", "builtin_ia32_hreset", "(", "_", "_", "EAX", ")", ";" ]

[ ";" ]

[ "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "PM", ".", "add", "(", "createNEONMoveFixPass", "(", ")", ")", ";", "}", "PM", ".", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "return", "true" ]

[ "==", "Store", ";" ]

[ "return", "Type" ]

[ "<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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<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", "=" ]

[ "DPR", ":", "$", "a", ")", ",", "GPR", ")", ")", ">", ",", "Requires", "<", "[", "HasFPARMv8", ",", "HasDPVFP", "]", ">", ";" ]

[ "def", ":", "FP16Pat", "<", "(", "fp_to_f16", "(", "f64", "DPR", ":", "$", "a", ")", ")", ",", "(", "i32", "(", "COPY_TO_REGCLASS", "(", "VCVTBDH" ]

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

[ "return", "true", ";", "}", "if", "(", "CSKY_ISA_FEATURE", "(", "E2", ")", "&&", "csky_literal_I_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", "return", "false", ";", "if", "(", "popcount_hwi", "(", "mask", "&", "<NUM_LIT>", ")", "<=", "(", "reload_completed", "&&", "!", "CSKY_ISA_FEATURE", "(", "E2", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", "{", "rtx", "input", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "!", "CSKY_ISA_FEATURE", "(", "E2", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "input", ")", ";" ]

[ "const", "{" ]

[ "const", "PPCRegisterInfo", "&", "getRegisterInfo", "(", ")" ]