Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "unsigned", "size", "(", "const", "agraph", "&", "G", ")", "{", "return", "G", ".", "Blocks", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "DataTy", ",", "MaybeAlign", "Alignment", ")", "{", "if", "(", "!", "(", "ST", "->", "hasAVX512", "(", ")", "||", "(", "ST", "->", "hasFastGather", "(", ")", "&&", "ST", "->", "hasAVX2", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", ")", "{", "unsigned", "NumElts", "=", "DataTy", "->", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "1", "||", "!", "isPowerOf2_32", "(", "NumElts", ")", ")", "return", "false", ";", "}", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "if", "(", "ScalarTy", "->", "isPointerTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isFloatTy", "(", ")", "||", "ScalarTy", "->", "isDoubleTy", "(", ")", ")", "return", "true", ";", "if", "(", "!", "ScalarTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "unsigned", "IntWidth", "=", "ScalarTy", "->", "getIntegerBitWidth", "(", ")", ";", "return", "IntWidth", "==", "32", "||", "IntWidth", "==", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

[ "X86", "X86", "1", "32", "64" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "ADD_F128", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "SUB_F128", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "MUL_F128", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "DIV_F128", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "LowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerFP_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "AArch64", "AArch64", "\"Don't know how to custom lower this!\"", "ISD::FADD", "ISD::FSUB", "ISD::FMUL", "ISD::FDIV", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_ROUND", "ISD::FP_EXTEND", "ISD::BlockAddress", "ISD::BRCOND", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VACOPY", "ISD::VASTART", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "static", "void", "save_reg", "(", "int", "regno", ",", "unsigned", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ",", "false", ")", ";", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Generate", "save/restore", "of", "register", "REGNO", "at", "SP", "+", "OFFSET", ".", "Used", "by", "the", "prologue/epilogue", "expand", "routines", "." ]

[ "nios2", "1" ]

[]

[ "<s>", "static", "void", "thumb_pop", "(", "FILE", "*", "f", ",", "unsigned", "long", "mask", ")", "{", "int", "regno", ";", "int", "lo_mask", "=", "mask", "&", "0xFF", ";", "int", "pushed_words", "=", "0", ";", "gcc_assert", "(", "mask", ")", ";", "if", "(", "lo_mask", "==", "0", "&&", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", ")", "{", "thumb_exit", "(", "f", ",", "-", "1", ")", ";", "return", ";", "}", "fprintf", "(", "f", ",", "\"\\tpop\\t{\"", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ",", "lo_mask", ">>=", "1", ")", "{", "if", "(", "lo_mask", "&", "1", ")", "{", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "regno", ")", ";", "if", "(", "(", "lo_mask", "&", "~", "1", ")", "!=", "0", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "pushed_words", "++", ";", "}", "}", "if", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", "{", "if", "(", "TARGET_INTERWORK", "||", "TARGET_BACKTRACE", "||", "crtl", "->", "calls_eh_return", "||", "IS_CMSE_ENTRY", "(", "arm_current_func_type", "(", ")", ")", ")", "{", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "thumb_exit", "(", "f", ",", "-", "1", ")", ";", "return", ";", "}", "else", "{", "if", "(", "mask", "&", "0xFF", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "PC_REGNUM", ")", ";", "}", "}", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "push", "or", "pop", "registers", "to", "or", "from", "the", "stack", ".", "F", "is", "the", "assembly", "file", ".", "MASK", "is", "the", "registers", "to", "pop", "." ]

[ "arm", "0xFF", "0", "0", "1", "1", "\"\\tpop\\t{\"", "0", "1", "1", "\"%r\"", "1", "0", "\", \"", "1", "\"}\\n\"", "1", "0xFF", "\", \"", "\"%r\"", "\"}\\n\"" ]

[]

[ "<s>", "machine_mode", "ix86_fp_compare_mode", "(", "enum", "rtx_code", ")", "{", "return", "TARGET_IEEE_FP", "?", "CCFPUmode", ":", "CCFPmode", ";", "}", "</s>" ]

[ "Figure", "out", "whether", "to", "use", "ordered", "or", "unordered", "fp", "comparisons", ".", "Return", "the", "appropriate", "mode", "to", "use", "." ]

[ "i386" ]

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getGlobalBaseReg", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "int", "arc_save_callee_enter", "(", "unsigned", "int", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ")", "{", "int", "start_reg", "=", "ENTER_LEAVE_START_REG", ";", "int", "end_reg", "=", "ENTER_LEAVE_END_REG", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "nregs", "+=", "save_blink", "?", "1", ":", "0", ";", "nregs", "+=", "save_fp", "?", "1", ":", "0", ";", "if", "(", "offset", ")", "frame_stack_add", "(", "offset", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "(", "save_fp", "?", "1", ":", "0", ")", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "reg", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "nregs", "*", "UNITS_PER_WORD", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "reg", ")", "=", "1", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", "=", "reg", ";", "off", "=", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "save_blink", "=", "false", ";", "}", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "-=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1L", "<<", "regno", ")", ";", "}", "if", "(", "save_fp", ")", "{", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "hard_frame_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "save_fp", "=", "false", ";", "}", "gcc_assert", "(", "off", "==", "0", ")", ";", "insn", "=", "frame_insn", "(", "insn", ")", ";", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "frame_allocated", "=", "nregs", "*", "UNITS_PER_WORD", ";", "return", "frame_allocated", "-", "offset", ";", "}", "</s>" ]

[ "ARC", "prologue", ",", "save", "the", "registers", "using", "enter", "instruction", ".", "Leave", "instruction", "can", "also", "save", "$", "blink", "(", "SAVE_BLINK", ")", "and", "$", "fp", "(", "SAVE_FP", ")", "register", "." ]

[ "arc", "0", "1L", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "1", "1L", "0", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "rtx", "disi_highpart", "(", "rtx", "in", ")", "{", "return", "simplify_gen_subreg", "(", "SImode", ",", "in", ",", "DImode", ",", "TARGET_BIG_ENDIAN", "?", "0", ":", "4", ")", ";", "}", "</s>" ]

[ "Return", "the", "SImode", "highpart", "of", "the", "DImode", "value", "IN", "." ]

[ "arc", "0", "4" ]

[]

[ "<s>", "void", "P2TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "Base", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "ProgmemDataSection", "=", "Ctx", ".", "getELFSection", "(", "\".progmem.data\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "P2", "P2", "\".progmem.data\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "while", "(", "++", "I", "!=", "E", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "int", "PIdx", "=", "I", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "1", "&&", "I", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", "!=", "ARMCC", "::", "AL", ")", "return", "true", ";", "}", "return", "false", ";", "}", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "return", "PIdx", "!=", "-", "1", "&&", "MI", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", "!=", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "ARM", "ARM", "1", "ARMCC::AL", "1", "ARMCC::AL" ]

[]

[ "<s>", "MipsTargetLowering", "::", "ConstraintType", "MipsTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "Mips", "Mips", "Mips", "1", "0" ]

[]

[ "<s>", "X86TargetLowering", "::", "ConstraintType", "X86TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'R'", ":", "case", "'q'", ":", "case", "'Q'", ":", "case", "'f'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'y'", ":", "case", "'x'", ":", "case", "'v'", ":", "case", "'l'", ":", "case", "'k'", ":", "return", "C_RegisterClass", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'c'", ":", "case", "'d'", ":", "case", "'S'", ":", "case", "'D'", ":", "case", "'A'", ":", "return", "C_Register", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'N'", ":", "case", "'G'", ":", "case", "'L'", ":", "case", "'M'", ":", "return", "C_Immediate", ";", "case", "'C'", ":", "case", "'e'", ":", "case", "'Z'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'Y'", ":", "switch", "(", "Constraint", "[", "1", "]", ")", "{", "default", ":", "break", ";", "case", "'z'", ":", "return", "C_Register", ";", "case", "'i'", ":", "case", "'m'", ":", "case", "'k'", ":", "case", "'t'", ":", "case", "'2'", ":", "return", "C_RegisterClass", ";", "}", "}", "}", "else", "if", "(", "parseConstraintCode", "(", "Constraint", ")", "!=", "X86", "::", "COND_INVALID", ")", "return", "C_Other", ";", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "X86", "X86", "X86", "1", "0", "2", "0", "1", "X86::COND_INVALID" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "Q", ".", "empty", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "MipsSubtarget", "::", "resetSubtarget", "(", "MachineFunction", "*", "MF", ")", "{", "bool", "ChangeToMips16", "=", "false", ",", "ChangeToNoMips16", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"resetSubtargetFeatures\"", "<<", "\"\\n\"", ")", ";", "AttributeSet", "FnAttrs", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "ChangeToMips16", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"mips16\"", ")", ";", "ChangeToNoMips16", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"nomips16\"", ")", ";", "assert", "(", "!", "(", "ChangeToMips16", "&", "ChangeToNoMips16", ")", "&&", "\"mips16 and nomips16 specified on the same function\"", ")", ";", "if", "(", "ChangeToMips16", ")", "{", "if", "(", "PreviousInMips16Mode", ")", "return", ";", "OverrideMode", "=", "Mips16Override", ";", "PreviousInMips16Mode", "=", "true", ";", "TM", "->", "setHelperClassesMips16", "(", ")", ";", "return", ";", "}", "else", "if", "(", "ChangeToNoMips16", ")", "{", "if", "(", "!", "PreviousInMips16Mode", ")", "return", ";", "OverrideMode", "=", "NoMips16Override", ";", "PreviousInMips16Mode", "=", "false", ";", "TM", "->", "setHelperClassesMipsSE", "(", ")", ";", "return", ";", "}", "else", "{", "if", "(", "OverrideMode", "==", "NoOverride", ")", "return", ";", "OverrideMode", "=", "NoOverride", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"back to default\"", "<<", "\"\\n\"", ")", ";", "if", "(", "inMips16Mode", "(", ")", "&&", "!", "PreviousInMips16Mode", ")", "{", "TM", "->", "setHelperClassesMips16", "(", ")", ";", "PreviousInMips16Mode", "=", "true", ";", "}", "else", "if", "(", "!", "inMips16Mode", "(", ")", "&&", "PreviousInMips16Mode", ")", "{", "TM", "->", "setHelperClassesMipsSE", "(", ")", ";", "PreviousInMips16Mode", "=", "false", ";", "}", "return", ";", "}", "}", "</s>" ]

[ "Reset", "the", "subtarget", "for", "the", "Mips", "target", "." ]

[ "Mips", "Mips", "Mips", "Mips", "\"resetSubtargetFeatures\"", "\"\\n\"", "Mips", "\"mips16\"", "Mips", "\"nomips16\"", "Mips", "Mips", "\"mips16 and nomips16 specified on the same function\"", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"back to default\"", "\"\\n\"", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "RISCV", "::", "HwlpBranch", ")", "{", "return", "true", ";", "}", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"Invalid branch condition!\"", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "getOppositeBranchOpcode", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "RISCV", "RISCV", "0", "RISCV::HwlpBranch", "3", "\"Invalid branch condition!\"", "0", "0" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "RealignStack", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "return", "RISCVMatInt", "::", "getIntMatCost", "(", "Imm", ",", "DL", ".", "getTypeSizeInBits", "(", "Ty", ")", ",", "getST", "(", ")", "->", "is64Bit", "(", ")", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "RISCVMatInt::getIntMatCost" ]

[]

[ "<s>", "static", "const", "char", "*", "mmix_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "for", "(", ";", "(", "*", "name", "==", "'@'", "||", "*", "name", "==", "'*'", ")", ";", "name", "++", ")", ";", "return", "name", ";", "}", "</s>" ]

[ "STRIP_NAME_ENCODING", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "bool", "avr_function_ok_for_sibcall", "(", "tree", "decl_callee", ",", "tree", "exp_callee", ")", "{", "tree", "fntype_callee", ";", "if", "(", "cfun", "->", "machine", "->", "sibcall_fails", "||", "TARGET_CALL_PROLOGUES", ")", "{", "return", "false", ";", "}", "fntype_callee", "=", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp_callee", ")", ")", ";", "if", "(", "decl_callee", ")", "{", "decl_callee", "=", "TREE_TYPE", "(", "decl_callee", ")", ";", "}", "else", "{", "decl_callee", "=", "fntype_callee", ";", "while", "(", "FUNCTION_TYPE", "!=", "TREE_CODE", "(", "decl_callee", ")", "&&", "METHOD_TYPE", "!=", "TREE_CODE", "(", "decl_callee", ")", ")", "{", "decl_callee", "=", "TREE_TYPE", "(", "decl_callee", ")", ";", "}", "}", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_naked", "||", "avr_naked_function_p", "(", "decl_callee", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "avr" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "X86AsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "X86", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_movq_load\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_relax\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_relax_rex\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_signed_4byte\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_signed_4byte_relax\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_global_offset_table\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"reloc_global_offset_table8\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"reloc_branch_4byte_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "assert", "(", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ".", "Name", "&&", "\"Empty fixup name!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "X86", "X86", "X86::NumTargetFixupKinds", "\"reloc_riprel_4byte\"", "0", "32", "\"reloc_riprel_4byte_movq_load\"", "0", "32", "\"reloc_riprel_4byte_relax\"", "0", "32", "\"reloc_riprel_4byte_relax_rex\"", "0", "32", "\"reloc_signed_4byte\"", "0", "32", "0", "\"reloc_signed_4byte_relax\"", "0", "32", "0", "\"reloc_global_offset_table\"", "0", "32", "0", "\"reloc_global_offset_table8\"", "0", "64", "0", "\"reloc_branch_4byte_pcrel\"", "0", "32", "\"Invalid kind!\"", "\"Empty fixup name!\"" ]

[]

[ "<s>", "static", "tree", "fully_fold_convert", "(", "tree", "type", ",", "tree", "expr", ")", "{", "tree", "result", "=", "fold_convert", "(", "type", ",", "expr", ")", ";", "bool", "maybe_const", "=", "true", ";", "if", "(", "!", "c_dialect_cxx", "(", ")", ")", "result", "=", "c_fully_fold", "(", "result", ",", "false", ",", "&", "maybe_const", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "In", "addition", "to", "calling", "fold_convert", "for", "EXPR", "of", "type", "TYPE", ",", "also", "call", "c_fully_fold", "to", "remove", "any", "C_MAYBE_CONST_EXPRs", "that", "could", "be", "hiding", "there", "(", "PR47197", ")", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_value", "(", "unsigned", "HOST_WIDE_INT", "val", ",", "unsigned", "size", ")", "{", "val", "&=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "2", "<<", "(", "size", "*", "BITS_PER_UNIT", "-", "1", ")", ")", "-", "1", ";", "for", "(", "unsigned", "part", "=", "0", ";", "size", ";", "size", "-=", "part", ")", "{", "val", ">>=", "part", "*", "BITS_PER_UNIT", ";", "part", "=", "init_frag", ".", "size", "-", "init_frag", ".", "offset", ";", "if", "(", "part", ">", "size", ")", "part", "=", "size", ";", "unsigned", "HOST_WIDE_INT", "partial", "=", "val", "<<", "(", "init_frag", ".", "offset", "*", "BITS_PER_UNIT", ")", ";", "init_frag", ".", "val", "|=", "partial", "&", "init_frag", ".", "mask", ";", "init_frag", ".", "offset", "+=", "part", ";", "if", "(", "init_frag", ".", "offset", "==", "init_frag", ".", "size", ")", "output_init_frag", "(", "NULL", ")", ";", "}", "}", "</s>" ]

[ "Add", "value", "VAL", "sized", "SIZE", "to", "the", "data", "we", "'re", "emitting", ",", "and", "keep", "writing", "out", "chunks", "as", "they", "fill", "up", "." ]

[ "nvptx", "2", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "abort_with_insn", "(", "rtx", "insn", ",", "const", "char", "*", "reason", ")", "{", "error", "(", "reason", ")", ";", "debug_rtx", "(", "insn", ")", ";", "fancy_abort", "(", "__FILE__", ",", "__LINE__", ",", "__FUNCTION__", ")", ";", "}", "</s>" ]

[ "Abort", "after", "printing", "out", "a", "specific", "insn", "." ]

[ "iq2000" ]

[]

[ "<s>", "NVPTXSubtarget", "&", "NVPTXSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "TargetName", "=", "CPU", ".", "empty", "(", ")", "?", "\"sm_20\"", ":", "CPU", ";", "ParseSubtargetFeatures", "(", "TargetName", ",", "FS", ")", ";", "if", "(", "PTXVersion", "==", "0", ")", "{", "PTXVersion", "=", "32", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "\"sm_20\"", "0", "32" ]

[]

[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "const", "char", "*", "p", ";", "if", "(", "is64Bit", "(", ")", ")", "p", "=", "\"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-\"", "\"f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-\"", "\"n16:32:64\"", ";", "else", "p", "=", "\"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-\"", "\"f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-\"", "\"n16:32:64\"", ";", "return", "std", "::", "string", "(", "p", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "NVPTX", "\"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-\"", "\"f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-\"", "\"n16:32:64\"", "\"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-\"", "\"f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-\"", "\"n16:32:64\"" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "Module", "&", "M", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "thumb", ")", ":", "ARMArchVersion", "(", "V4T", ")", ",", "HasVFP2", "(", "false", ")", ",", "IsThumb", "(", "thumb", ")", ",", "UseThumbBacktraces", "(", "false", ")", ",", "IsR9Reserved", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "TargetType", "(", "isELF", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "std", "::", "string", "CPU", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "const", "std", "::", "string", "&", "TT", "=", "M", ".", "getTargetTriple", "(", ")", ";", "unsigned", "Len", "=", "TT", ".", "length", "(", ")", ";", "unsigned", "Idx", "=", "0", ";", "if", "(", "Len", ">=", "5", "&&", "TT", ".", "substr", "(", "0", ",", "4", ")", "==", "\"armv\"", ")", "Idx", "=", "4", ";", "else", "if", "(", "Len", ">=", "6", "&&", "TT", ".", "substr", "(", "0", ",", "6", ")", "==", "\"thumb\"", ")", "{", "IsThumb", "=", "true", ";", "if", "(", "Len", ">=", "7", "&&", "TT", "[", "5", "]", "==", "'v'", ")", "Idx", "=", "6", ";", "}", "if", "(", "Idx", ")", "{", "unsigned", "SubVer", "=", "TT", "[", "Idx", "]", ";", "if", "(", "SubVer", ">", "'4'", "&&", "SubVer", "<=", "'9'", ")", "{", "if", "(", "SubVer", ">=", "'6'", ")", "ARMArchVersion", "=", "V6", ";", "else", "if", "(", "SubVer", "==", "'5'", ")", "{", "ARMArchVersion", "=", "V5T", ";", "if", "(", "Len", ">=", "Idx", "+", "3", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", "&&", "TT", "[", "Idx", "+", "2", "]", "==", "'e'", ")", "ARMArchVersion", "=", "V5TE", ";", "}", "}", "}", "if", "(", "Len", ">=", "10", ")", "{", "if", "(", "TT", ".", "find", "(", "\"-darwin\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetType", "=", "isDarwin", ";", "}", "else", "if", "(", "TT", ".", "empty", "(", ")", ")", "{", "TargetType", "=", "isDarwin", ";", "}", "if", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "UseThumbBacktraces", "=", "true", ";", "IsR9Reserved", "=", "true", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "ARM", "ARM", "ARM", "ARM", "4", "ARM", "\"generic\"", "0", "5", "0", "4", "\"armv\"", "4", "6", "0", "6", "\"thumb\"", "7", "5", "6", "ARM", "ARM", "3", "1", "2", "ARM", "10", "\"-darwin\"", "\"eabi\"", "ARM", "8" ]

[]

[ "<s>", "void", "ARMInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "aarch64_handle_attr_tune", "(", "const", "char", "*", "str", ",", "const", "char", "*", "pragma_or_attr", ")", "{", "const", "struct", "processor", "*", "tmp_tune", "=", "NULL", ";", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_tune", "(", "str", ",", "&", "tmp_tune", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "{", "gcc_assert", "(", "tmp_tune", ")", ";", "selected_tune", "=", "tmp_tune", ";", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "return", "true", ";", "}", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"unknown value %qs for 'tune' target %s\"", ",", "str", ",", "pragma_or_attr", ")", ";", "aarch64_print_hint_for_core", "(", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Handle", "the", "argument", "STR", "to", "the", "tune=", "target", "attribute", ".", "PRAGMA_OR_ATTR", "is", "used", "in", "potential", "error", "messages", "." ]

[ "aarch64", "\"unknown value %qs for 'tune' target %s\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "first", "&&", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", "&&", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "R", ".", "first", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TRI", "->", "getMatchingSuperReg", "(", "R", ".", "first", ",", "PPC", "::", "sub_32", ",", "&", "PPC", "::", "G8RCRegClass", ")", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "}", "return", "R", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass", "MVT::i64", "PPC", "PPC", "PPC::GPRCRegClass", "PPC::sub_32", "PPC::G8RCRegClass", "PPC::G8RCRegClass" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "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", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "uint64_t", "NumElts", "=", "getTargetData", "(", ")", "->", "getTypeAllocSize", "(", "I", ".", "getType", "(", ")", ")", "/", "8", ";", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Value", "*", "AlignArg", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "1", ")", ";", "Info", ".", "align", "=", "cast", "<", "ConstantInt", ">", "(", "AlignArg", ")", "->", "getZExtValue", "(", ")", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "return", "true", ";", "}", "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", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "unsigned", "NumElts", "=", "0", ";", "for", "(", "unsigned", "ArgI", "=", "1", ",", "ArgE", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "ArgI", "<", "ArgE", ";", "++", "ArgI", ")", "{", "const", "Type", "*", "ArgTy", "=", "I", ".", "getArgOperand", "(", "ArgI", ")", "->", "getType", "(", ")", ";", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "break", ";", "NumElts", "+=", "getTargetData", "(", ")", "->", "getTypeAllocSize", "(", "ArgTy", ")", "/", "8", ";", "}", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Value", "*", "AlignArg", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "1", ")", ";", "Info", ".", "align", "=", "cast", "<", "ConstantInt", ">", "(", "AlignArg", ")", "->", "getZExtValue", "(", ")", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "false", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "ARM", "ARM", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::arm_neon_vld2lane", "Intrinsic::arm_neon_vld3lane", "Intrinsic::arm_neon_vld4lane", "ISD::INTRINSIC_W_CHAIN", "8", "MVT::i64", "0", "0", "1", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "Intrinsic::arm_neon_vst2lane", "Intrinsic::arm_neon_vst3lane", "Intrinsic::arm_neon_vst4lane", "ISD::INTRINSIC_VOID", "0", "1", "8", "MVT::i64", "0", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MVE gather/scatter lowering\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARM", "\"MVE gather/scatter lowering\"" ]

[]

[ "<s>", "unsigned", "BPFMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getBPFRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "JAL", ")", "{", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_SecRel_4", ")", ")", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_SecRel_8", ")", ")", ";", "}", "else", "{", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_PCRel_2", ")", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "BPF", "BPF", "BPF", "BPF::JAL", "0", "BPF::LD_imm64", "0", "0", "0" ]

[]

[ "<s>", "bool", "aarch64_high_bits_all_ones_p", "(", "HOST_WIDE_INT", "i", ")", "{", "return", "exact_log2", "(", "-", "i", ")", "!=", "HOST_WIDE_INT_M1", ";", "}", "</s>" ]

[ "Return", "true", "if", "I", "'s", "bits", "are", "consecutive", "ones", "from", "the", "MSB", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "MSP430AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", ")", "EmitInterruptVectorSection", "(", "MF", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "rtx", "conditionalize_nonjump", "(", "rtx", "pat", ",", "rtx", "cond", ",", "rtx", "insn", ",", "bool", "annulled", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "COMMUTATIVE_P", "(", "src", ")", ")", "{", "rtx", "src0", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src1", "=", "XEXP", "(", "src", ",", "1", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "if", "(", "rtx_equal_p", "(", "src1", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "src0", ",", "dst", ")", "&&", "REG_P", "(", "src0", ")", ")", "pat", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "src", ")", ",", "GET_MODE", "(", "src", ")", ",", "src1", ",", "src0", ")", ")", ";", "}", "}", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", "{", "gcc_assert", "(", "annulled", ")", ";", "rtx", "note", "=", "alloc_reg_note", "(", "REG_FRAME_RELATED_EXPR", ",", "pat", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "validate_change", "(", "insn", ",", "&", "REG_NOTES", "(", "insn", ")", ",", "note", ",", "1", ")", ";", "}", "pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "cond", ",", "pat", ")", ";", "return", "pat", ";", "}", "</s>" ]

[ "Return", "version", "of", "PAT", "conditionalized", "with", "COND", ",", "which", "is", "part", "of", "INSN", ".", "ANNULLED", "indicates", "if", "INSN", "is", "an", "annulled", "delay-slot", "insn", ".", "Register", "further", "changes", "if", "necessary", "." ]

[ "arc", "0", "1", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "PPCSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "DisableVSXFMAMutate", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "X86IndirectBranchTrackingPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "SubTarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "Metadata", "*", "isCFProtectionSupported", "=", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ";", "if", "(", "!", "isCFProtectionSupported", "&&", "!", "IndirectBranchTracking", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "SubTarget", ".", "getInstrInfo", "(", ")", ";", "EndbrOpcode", "=", "SubTarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "ENDBR64", ":", "X86", "::", "ENDBR32", ";", "if", "(", "(", "MF", ".", "getFunction", "(", ")", ".", "hasAddressTaken", "(", ")", "||", "!", "MF", ".", "getFunction", "(", ")", ".", "hasLocalLinkage", "(", ")", ")", "&&", "!", "MF", ".", "getFunction", "(", ")", ".", "doesNoCfCheck", "(", ")", ")", "{", "auto", "MBB", "=", "MF", ".", "begin", "(", ")", ";", "Changed", "|=", "addENDBR", "(", "*", "MBB", ",", "MBB", "->", "begin", "(", ")", ")", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "isCall", "(", ")", ")", "continue", ";", "if", "(", "IsCallReturnTwice", "(", "I", "->", "getOperand", "(", "0", ")", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"cf-protection-branch\"", "X86::ENDBR64", "X86::ENDBR32", "0" ]

[]

[ "<s>", "void", "general_scalar_chain", "::", "make_vector_copies", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ")", "{", "rtx", "vreg", "=", "*", "defs_map", ".", "get", "(", "reg", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", "{", "rtx", "tmp", "=", "assign_386_stack_local", "(", "smode", ",", "SLOT_STV_TEMP", ")", ";", "if", "(", "smode", "==", "DImode", "&&", "!", "TARGET_64BIT", ")", "{", "emit_move_insn", "(", "adjust_address", "(", "tmp", ",", "SImode", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "0", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tmp", ",", "SImode", ",", "4", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "4", ")", ")", ";", "}", "else", "emit_move_insn", "(", "copy_rtx", "(", "tmp", ")", ",", "reg", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "vmode", ",", "vreg", ",", "0", ")", ",", "gen_gpr_to_xmm_move_src", "(", "vmode", ",", "tmp", ")", ")", ")", ";", "}", "else", "if", "(", "!", "TARGET_64BIT", "&&", "smode", "==", "DImode", ")", "{", "if", "(", "TARGET_SSE4_1", ")", "{", "emit_insn", "(", "gen_sse2_loadld", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "0", ")", ")", ")", ";", "emit_insn", "(", "gen_sse4_1_pinsrd", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "4", ")", ",", "GEN_INT", "(", "2", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_sse2_loadld", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "0", ")", ")", ")", ";", "emit_insn", "(", "gen_sse2_loadld", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "tmp", ",", "0", ")", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "4", ")", ")", ")", ";", "emit_insn", "(", "gen_vec_interleave_lowv4si", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "tmp", ",", "0", ")", ")", ")", ";", "}", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "vmode", ",", "vreg", ",", "0", ")", ",", "gen_gpr_to_xmm_move_src", "(", "vmode", ",", "reg", ")", ")", ")", ";", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_conversion_insns", "(", "seq", ",", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Copied r%d to a vector register r%d for insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "REGNO", "(", "vreg", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Make", "vector", "copies", "for", "all", "register", "REGNO", "definitions", "and", "replace", "its", "uses", "in", "a", "chain", "." ]

[ "i386", "0", "0", "4", "4", "0", "0", "0", "0", "0", "4", "2", "0", "0", "0", "4", "0", "0", "0", "0", "\" Copied r%d to a vector register r%d for insn %d\\n\"" ]

[]

[ "<s>", "void", "ix86_override_options_after_change", "(", "void", ")", "{", "ix86_default_align", "(", "&", "global_options", ")", ";", "ix86_recompute_optlev_based_flags", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE", "hook", "." ]

[ "i386" ]

[]

[ "<s>", "static", "int", "arc_address_cost", "(", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "return", "2", ";", "case", "PLUS", ":", "{", "register", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "SMALL_INT", "(", "plus1", ")", "?", "1", ":", "2", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "2", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "." ]

[ "arc", "1", "2", "0", "1", "1", "2", "2", "4" ]

[]

[ "<s>", "bool", "Thumb2ITBlockPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", ")", "return", "false", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "restrictIT", "=", "STI", ".", "restrictIT", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "++", "MFI", ";", "Modified", "|=", "InsertITInstructions", "(", "MBB", ")", ";", "}", "if", "(", "Modified", ")", "AFI", "->", "setHasITBlocks", "(", "true", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ")", ";", "else", "if", "(", "IDVal", "==", "\".llong\"", ")", "ParseDirectiveWord", "(", "8", ",", "DirectiveID", ")", ";", "else", "if", "(", "IDVal", "==", "\".tc\"", ")", "ParseDirectiveTC", "(", "isPPC64", "(", ")", "?", "8", ":", "4", ",", "DirectiveID", ")", ";", "else", "if", "(", "IDVal", "==", "\".machine\"", ")", "ParseDirectiveMachine", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".abiversion\"", ")", "ParseDirectiveAbiVersion", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".localentry\"", ")", "ParseDirectiveLocalEntry", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".gnu_attribute\"", ")", ")", "ParseGNUAttribute", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "PowerPC", "PPC", "\".word\"", "2", "\".llong\"", "8", "\".tc\"", "PPC", "8", "4", "\".machine\"", "\".abiversion\"", "\".localentry\"", "\".gnu_attribute\"" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "getCmpLibcallReturnType", "(", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "ValueType", "for", "comparison", "libcalls", "." ]

[ "AVR", "MVT::SimpleValueType", "MVT::i8" ]

[]

[ "<s>", "unsigned", "MOSInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "const", "MOSSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "MOSSubtarget", ">", "(", ")", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ")", ";", "unsigned", "NumAdded", "=", "0", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "auto", "*", "UBB", "=", "TBB", ";", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "TBB", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", ";", "UBB", "=", "FBB", ";", "Register", "Reg", "=", "Cond", "[", "0", "]", ".", "getReg", "(", ")", ";", "unsigned", "Opcode", "=", "Reg", ".", "isVirtual", "(", ")", "||", "!", "MOS", "::", "FlagRegClass", ".", "contains", "(", "Reg", ")", "?", "MOS", "::", "GBR", ":", "MOS", "::", "BR", ";", "auto", "BR", "=", "Builder", ".", "buildInstr", "(", "Opcode", ")", ".", "addMBB", "(", "TBB", ")", ";", "for", "(", "const", "MachineOperand", "&", "Op", ":", "Cond", ")", "BR", ".", "add", "(", "Op", ")", ";", "++", "NumAdded", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "*", "BR", ")", ";", "}", "if", "(", "UBB", ")", "{", "auto", "JMP", "=", "Builder", ".", "buildInstr", "(", "STI", ".", "has65C02", "(", ")", "?", "MOS", "::", "BRA", ":", "MOS", "::", "JMP", ")", ".", "addMBB", "(", "UBB", ")", ";", "++", "NumAdded", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "*", "JMP", ")", ";", "}", "return", "NumAdded", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "MOS", "MOS", "MOS", "MOS", "0", "0", "2", "0", "MOS::FlagRegClass", "MOS::GBR", "MOS::BR", "MOS::BRA", "MOS::JMP" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "X86" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "EncodingAlignment", ")", "const", "{", "if", "(", "SelectAddressPCRel", "(", "N", ",", "Base", ")", ")", "return", "false", ";", "int16_t", "imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "hasSPE", "(", ")", "&&", "SelectAddressEVXRegReg", "(", "N", ",", "Base", ",", "Index", ",", "DAG", ")", ")", "return", "true", ";", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", "&&", "(", "!", "EncodingAlignment", "||", "!", "(", "imm", "%", "EncodingAlignment", ")", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "Lo", ")", "return", "false", ";", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", "&&", "(", "!", "EncodingAlignment", "||", "!", "(", "imm", "%", "EncodingAlignment", ")", ")", ")", "return", "false", ";", "KnownBits", "LHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "0", ")", ")", ";", "if", "(", "LHSKnown", ".", "Zero", ".", "getBoolValue", "(", ")", ")", "{", "KnownBits", "RHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "1", ")", ")", ";", "if", "(", "~", "(", "LHSKnown", ".", "Zero", "|", "RHSKnown", ".", "Zero", ")", "==", "0", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "PPCISD::Lo", "0", "1", "ISD::OR", "1", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "*", "Compare", ",", "unsigned", "SrcReg", ",", "unsigned", "SrcReg2", ",", "int", "Mask", ",", "int", "Value", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "!", "SrcReg2", "&&", "\"Only optimizing constant comparisons so far\"", ")", ";", "bool", "IsLogical", "=", "(", "Compare", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "SystemZII", "::", "IsLogical", ")", "!=", "0", ";", "if", "(", "Value", "==", "0", "&&", "!", "IsLogical", "&&", "removeIPMBasedCompare", "(", "Compare", ",", "SrcReg", ",", "MRI", ",", "&", "RI", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]

[ "SystemZ", "SystemZ", "\"Only optimizing constant comparisons so far\"", "SystemZII::IsLogical", "0", "0" ]

[]

[ "<s>", "void", "AArch64PreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "OR1K", "OR1K", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "void", "emit_pic_move", "(", "rtx", "*", "operands", ",", "machine_mode", ")", "{", "rtx", "temp", "=", "reload_in_progress", "?", "operands", "[", "0", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "1", "]", ")", ";", "else", "operands", "[", "1", "]", "=", "arc_legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

[ "arc", "0", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "unsigned", "getBasePointerSaveOffset", "(", ")", "const", "{", "return", "BasePointerSaveOffset", ";", "}", "</s>" ]

[ "getBasePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "base", "pointer", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "override", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "ARM64" ]

[]

[ "<s>", "unsigned", "MipsAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "Mips", "::", "JALR_HB", "&&", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresDifferentSrcAndDst", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "Mips", "Mips", "Mips::JALR_HB", "0", "1" ]

[]

[ "<s>", "int", "dead_register_here", "(", "rtx", "x", ",", "rtx", "reg", ")", "{", "rtx", "x_reg", ";", "rtx", "p", ";", "if", "(", "D_REG_P", "(", "reg", ")", ")", "x_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "HARD_X_REGNUM", ")", ";", "else", "x_reg", "=", "0", ";", "for", "(", "p", "=", "PREV_INSN", "(", "x", ")", ";", "p", "&&", "GET_CODE", "(", "p", ")", "!=", "CODE_LABEL", ";", "p", "=", "PREV_INSN", "(", "p", ")", ")", "if", "(", "INSN_P", "(", "p", ")", ")", "{", "rtx", "body", ";", "body", "=", "PATTERN", "(", "p", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "CALL_INSN", ")", "break", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "JUMP_INSN", ")", "break", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "rtx", "dst", "=", "XEXP", "(", "body", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "REG", "&&", "REGNO", "(", "dst", ")", "==", "REGNO", "(", "reg", ")", ")", "break", ";", "if", "(", "x_reg", "&&", "rtx_equal_p", "(", "dst", ",", "x_reg", ")", ")", "break", ";", "if", "(", "find_regno_note", "(", "p", ",", "REG_DEAD", ",", "REGNO", "(", "reg", ")", ")", ")", "return", "1", ";", "}", "else", "if", "(", "reg_mentioned_p", "(", "reg", ",", "p", ")", "||", "(", "x_reg", "&&", "reg_mentioned_p", "(", "x_reg", ",", "p", ")", ")", ")", "break", ";", "}", "for", "(", "p", "=", "x", ";", "p", ";", "p", "=", "NEXT_INSN", "(", "p", ")", ")", "{", "rtx", "body", ";", "if", "(", "GET_CODE", "(", "p", ")", "==", "CODE_LABEL", "||", "GET_CODE", "(", "p", ")", "==", "JUMP_INSN", "||", "GET_CODE", "(", "p", ")", "==", "CALL_INSN", "||", "GET_CODE", "(", "p", ")", "==", "BARRIER", ")", "break", ";", "if", "(", "GET_CODE", "(", "p", ")", "!=", "INSN", ")", "continue", ";", "body", "=", "PATTERN", "(", "p", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "rtx", "src", "=", "XEXP", "(", "body", ",", "1", ")", ";", "rtx", "dst", "=", "XEXP", "(", "body", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "REG", "&&", "REGNO", "(", "dst", ")", "==", "REGNO", "(", "reg", ")", "&&", "!", "reg_mentioned_p", "(", "reg", ",", "src", ")", ")", "return", "1", ";", "}", "if", "(", "reg_mentioned_p", "(", "reg", ",", "p", ")", "||", "(", "x_reg", "!=", "0", "&&", "GET_MODE", "(", "p", ")", "==", "SImode", "&&", "reg_mentioned_p", "(", "x_reg", ",", "p", ")", ")", ")", "break", ";", "}", "return", "p", "==", "0", "?", "1", ":", "0", ";", "}", "</s>" ]

[ "Finds", "backward", "in", "the", "instructions", "to", "see", "if", "register", "'reg", "'", "is", "dead", ".", "This", "is", "used", "when", "generating", "code", "to", "see", "if", "we", "can", "use", "'reg", "'", "as", "a", "scratch", "register", ".", "This", "allows", "us", "to", "choose", "a", "better", "generation", "of", "code", "when", "we", "know", "that", "some", "register", "dies", "or", "can", "be", "clobbered", "." ]

[ "m68hc11", "0", "0", "1", "1", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "else", "if", "(", "Constraint", "==", "\"wc\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "}", "else", "if", "(", "Constraint", "==", "\"wa\"", "||", "Constraint", "==", "\"wd\"", "||", "Constraint", "==", "\"wf\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "}", "else", "if", "(", "Constraint", "==", "\"ws\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VSFRCRegClass", ")", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "first", "&&", "VT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "isPPC64", "(", ")", "&&", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "R", ".", "first", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TRI", "->", "getMatchingSuperReg", "(", "R", ".", "first", ",", "PPC", "::", "sub_32", ",", "&", "PPC", "::", "G8RCRegClass", ")", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "}", "return", "R", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass", "\"wc\"", "0U", "PPC::CRBITRCRegClass", "\"wa\"", "\"wd\"", "\"wf\"", "0U", "PPC::VSRCRegClass", "\"ws\"", "0U", "PPC::VSFRCRegClass", "MVT::i64", "PPC", "PPC::GPRCRegClass", "PPC::sub_32", "PPC::G8RCRegClass", "PPC::G8RCRegClass" ]

[]

[ "<s>", "static", "tree", "bpf_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "if", "(", "is_attribute_p", "(", "\"kernel_helper\"", ",", "name", ")", ")", "{", "if", "(", "args", ")", "{", "tree", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "cst", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute requires an integer argument\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE requires an argument\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "bpf", "\"%qE attribute only applies to functions\"", "\"kernel_helper\"", "\"%qE attribute requires an integer argument\"", "\"%qE requires an argument\"" ]

[]

[ "<s>", "bool", "MipsSERegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"M68kISelAddressMode \"", "<<", "this", ";", "dbgs", "(", ")", "<<", "\"\\nDisp: \"", "<<", "Disp", ";", "dbgs", "(", ")", "<<", "\", BaseReg: \"", ";", "if", "(", "BaseReg", ".", "getNode", "(", ")", ")", "BaseReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"null\"", ";", "dbgs", "(", ")", "<<", "\", BaseFI: \"", "<<", "BaseFrameIndex", ";", "dbgs", "(", ")", "<<", "\", IndexReg: \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "{", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"null\"", ";", "dbgs", "(", ")", "<<", "\", Scale: \"", "<<", "Scale", ";", "}", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "M68k", "\"M68kISelAddressMode \"", "\"\\nDisp: \"", "\", BaseReg: \"", "\"null\"", "\", BaseFI: \"", "\", IndexReg: \"", "\"null\"", "\", Scale: \"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ",", "bool", "&", "UseOneConstNR", ",", "bool", "Reciprocal", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v8f32", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", ")", "{", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "1", ";", "UseOneConstNR", "=", "false", ";", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "FRSQRT", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Op", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "X86", "X86", "MVT::f32", "MVT::v4f32", "MVT::v8f32", "1", "X86ISD::FRSQRT" ]

[]

[ "<s>", "void", "frv_expand_epilogue", "(", "bool", "emit_return", ")", "{", "frv_stack_t", "*", "info", "=", "frv_stack_info", "(", ")", ";", "rtx", "fp", "=", "frame_pointer_rtx", ";", "rtx", "sp", "=", "stack_pointer_rtx", ";", "rtx", "return_addr", ";", "int", "fp_offset", ";", "fp_offset", "=", "info", "->", "reg_offset", "[", "FRAME_POINTER_REGNUM", "]", ";", "if", "(", "!", "crtl", "->", "sp_is_unchanging", ")", "emit_insn", "(", "gen_addsi3", "(", "sp", ",", "fp", ",", "frv_frame_offset_rtx", "(", "-", "fp_offset", ")", ")", ")", ";", "frv_frame_access_standard_regs", "(", "FRV_LOAD", ",", "info", ")", ";", "if", "(", "info", "->", "save_p", "[", "LR_REGNO", "]", ")", "{", "int", "lr_offset", ";", "rtx", "mem", ";", "lr_offset", "=", "info", "->", "reg_offset", "[", "LR_REGNO", "]", ";", "if", "(", "frame_pointer_needed", ")", "mem", "=", "frv_frame_mem", "(", "Pmode", ",", "fp", ",", "lr_offset", "-", "fp_offset", ")", ";", "else", "mem", "=", "frv_frame_mem", "(", "Pmode", ",", "sp", ",", "lr_offset", ")", ";", "return_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "return_addr", ",", "mem", ")", ")", ";", "}", "else", "return_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "fp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "fp", ")", ")", ")", ";", "emit_use", "(", "fp", ")", ";", "}", "if", "(", "info", "->", "total_size", "!=", "0", ")", "{", "rtx", "offset", "=", "frv_frame_offset_rtx", "(", "info", "->", "total_size", ")", ";", "emit_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "offset", ")", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "emit_return", ")", "emit_jump_insn", "(", "gen_epilogue_return", "(", "return_addr", ")", ")", ";", "else", "{", "rtx", "lr", "=", "return_addr", ";", "if", "(", "REGNO", "(", "return_addr", ")", "!=", "LR_REGNO", ")", "{", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "emit_move_insn", "(", "lr", ",", "return_addr", ")", ";", "}", "emit_use", "(", "lr", ")", ";", "}", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "epilogue", ".", "Using", "an", "epilogue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "the", "TARGET_ASM_FUNCTION_PROLOGUE", "target", "hook", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", "." ]

[ "frv", "0" ]

[]

[ "<s>", "bool", "sh_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SHMEDIA_FPU", "&&", "(", "(", "mode", "==", "V2SFmode", ")", "||", "(", "mode", "==", "V4SFmode", ")", "||", "(", "mode", "==", "V16SFmode", ")", ")", ")", "return", "true", ";", "else", "if", "(", "TARGET_SHMEDIA", "&&", "(", "(", "mode", "==", "V8QImode", ")", "||", "(", "mode", "==", "V2HImode", ")", "||", "(", "mode", "==", "V4HImode", ")", "||", "(", "mode", "==", "V2SImode", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "sh" ]

[]

[ "<s>", "static", "rtx", "m32c_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "mode", "==", "DFmode", ")", "{", "rtx", "rv", ";", "rv", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "4", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R0_REGNO", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R1_REGNO", ")", ",", "GEN_INT", "(", "2", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "2", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R2_REGNO", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "3", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R3_REGNO", ")", ",", "GEN_INT", "(", "6", ")", ")", ";", "return", "rv", ";", "}", "if", "(", "TARGET_A24", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "2", ")", "{", "rtx", "rv", ";", "rv", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "1", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "R0_REGNO", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", "rv", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "2", ")", "return", "gen_rtx_REG", "(", "mode", ",", "MEM0_REGNO", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "R0_REGNO", ")", ";", "}", "</s>" ]

[ "Implements", "LIBCALL_VALUE", ".", "Most", "values", "are", "returned", "in", "$", "r0", ",", "or", "some", "combination", "of", "registers", "starting", "there", "(", "r2r0", "for", "longs", ",", "r3r1r2r0", "for", "long", "long", ",", "r3r2r1r0", "for", "doubles", ")", ",", "except", "that", "that", "ABI", "currently", "does", "n't", "work", "because", "it", "ends", "up", "using", "all", "available", "general", "registers", "and", "gcc", "often", "ca", "n't", "compile", "it", ".", "So", ",", "instead", ",", "we", "return", "anything", "bigger", "than", "16", "bits", "in", "``", "mem0", "''", "(", "effectively", ",", "a", "memory", "location", ")", "." ]

[ "m32c", "4", "0", "0", "0", "0", "1", "2", "0", "2", "4", "0", "3", "6", "2", "1", "0", "0", "0", "2" ]

[]

[ "<s>", "static", "int", "optimal_immediate_sequence", "(", "enum", "rtx_code", "code", ",", "unsigned", "HOST_WIDE_INT", "val", ",", "struct", "four_ints", "*", "return_sequence", ")", "{", "int", "best_consecutive_zeros", "=", "0", ";", "int", "i", ";", "int", "best_start", "=", "0", ";", "int", "insns1", ",", "insns2", ";", "struct", "four_ints", "tmp_sequence", ";", "if", "(", "TARGET_ARM", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "+=", "2", ")", "{", "int", "consecutive_zeros", "=", "0", ";", "if", "(", "!", "(", "val", "&", "(", "3", "<<", "i", ")", ")", ")", "{", "while", "(", "(", "i", "<", "32", ")", "&&", "!", "(", "val", "&", "(", "3", "<<", "i", ")", ")", ")", "{", "consecutive_zeros", "+=", "2", ";", "i", "+=", "2", ";", "}", "if", "(", "consecutive_zeros", ">", "best_consecutive_zeros", ")", "{", "best_consecutive_zeros", "=", "consecutive_zeros", ";", "best_start", "=", "i", "-", "consecutive_zeros", ";", "}", "i", "-=", "2", ";", "}", "}", "}", "insns1", "=", "optimal_immediate_sequence_1", "(", "code", ",", "val", ",", "return_sequence", ",", "best_start", ")", ";", "if", "(", "best_start", "!=", "0", "&&", "(", "(", "HOST_WIDE_INT_1U", "<<", "best_start", ")", "<", "val", ")", ")", "{", "insns2", "=", "optimal_immediate_sequence_1", "(", "code", ",", "val", ",", "&", "tmp_sequence", ",", "0", ")", ";", "if", "(", "insns2", "<=", "insns1", ")", "{", "*", "return_sequence", "=", "tmp_sequence", ";", "insns1", "=", "insns2", ";", "}", "}", "return", "insns1", ";", "}", "</s>" ]

[ "Return", "a", "sequence", "of", "integers", ",", "in", "RETURN_SEQUENCE", "that", "fit", "into", "ARM/THUMB2", "immediates", ",", "and", "add", "up", "to", "VAL", ".", "Thr", "function", "return", "value", "gives", "the", "number", "of", "insns", "required", "." ]

[ "arm", "0", "0", "0", "32", "2", "0", "3", "32", "3", "2", "2", "2", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.amdgcn.queue.ptr\"", ",", "\"amdgpu-queue-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "{", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-queue-ptr\"", ")", ")", "continue", ";", "if", "(", "hasAddrSpaceCast", "(", "F", ")", ")", "F", ".", "addFnAttr", "(", "\"amdgpu-queue-ptr\"", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.amdgcn.queue.ptr\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"" ]

[]

[ "<s>", "bool", "FISCRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "FISC", "FISC" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "EXTSW_32", ":", "return", "\"PPCISD::EXTSW_32\"", ";", "case", "PPCISD", "::", "STD_32", ":", "return", "\"PPCISD::STD_32\"", ";", "case", "PPCISD", "::", "CALL_ELF", ":", "return", "\"PPCISD::CALL_ELF\"", ";", "case", "PPCISD", "::", "CALL_Macho", ":", "return", "\"PPCISD::CALL_Macho\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL_Macho", ":", "return", "\"PPCISD::BCTRL_Macho\"", ";", "case", "PPCISD", "::", "BCTRL_ELF", ":", "return", "\"PPCISD::BCTRL_ELF\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "MFCR", ":", "return", "\"PPCISD::MFCR\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "MTFSB0", ":", "return", "\"PPCISD::MTFSB0\"", ";", "case", "PPCISD", "::", "MTFSB1", ":", "return", "\"PPCISD::MTFSB1\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "MTFSF", ":", "return", "\"PPCISD::MTFSF\"", ";", "case", "PPCISD", "::", "TAILCALL", ":", "return", "\"PPCISD::TAILCALL\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::EXTSW_32", "\"PPCISD::EXTSW_32\"", "PPCISD::STD_32", "\"PPCISD::STD_32\"", "PPCISD::CALL_ELF", "\"PPCISD::CALL_ELF\"", "PPCISD::CALL_Macho", "\"PPCISD::CALL_Macho\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL_Macho", "\"PPCISD::BCTRL_Macho\"", "PPCISD::BCTRL_ELF", "\"PPCISD::BCTRL_ELF\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::MFCR", "\"PPCISD::MFCR\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::MTFSB0", "\"PPCISD::MTFSB0\"", "PPCISD::MTFSB1", "\"PPCISD::MTFSB1\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::MTFSF", "\"PPCISD::MTFSF\"", "PPCISD::TAILCALL", "\"PPCISD::TAILCALL\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"" ]

[]

[ "<s>", "bool", "Tile64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "static_cast", "<", "Tile64TargetMachine", "*", ">", "(", "TM", ")", "->", "getSubtargetImpl", "(", ")", "->", "isVLIWEnabled", "(", ")", ")", "{", "addPass", "(", "createTile64VLIWPacketizer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Tile64" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "markPhysRegUsed", "(", "PhysReg", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "{", "unsigned", "PhysRegSize", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegSizeInBits", "(", "PhysReg", ",", "MRI", ")", ";", "unsigned", "ValSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "unsigned", "LocSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "PhysRegSize", ">", "ValSize", "&&", "LocSize", "==", "ValSize", ")", "{", "auto", "Copy", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "::", "scalar", "(", "PhysRegSize", ")", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "Copy", ")", ";", "return", ";", "}", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "break", ";", "}", "case", "CCValAssign", "::", "LocInfo", "::", "SExt", ":", "case", "CCValAssign", "::", "LocInfo", "::", "ZExt", ":", "case", "CCValAssign", "::", "LocInfo", "::", "AExt", ":", "{", "auto", "Copy", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "{", "VA", ".", "getLocVT", "(", ")", "}", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "Copy", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "X86" ]

[]

[ "<s>", "char", "*", "function_builder", "::", "get_name", "(", "const", "function_instance", "&", "instance", ",", "bool", "overloaded_p", ")", "{", "append_name", "(", "instance", ".", "base_name", ")", ";", "if", "(", "overloaded_p", ")", "switch", "(", "instance", ".", "displacement_units", "(", ")", ")", "{", "case", "UNITS_none", ":", "break", ";", "case", "UNITS_bytes", ":", "append_name", "(", "\"_offset\"", ")", ";", "break", ";", "case", "UNITS_elements", ":", "append_name", "(", "\"_index\"", ")", ";", "break", ";", "case", "UNITS_vectors", ":", "append_name", "(", "\"_vnum\"", ")", ";", "break", ";", "}", "else", "append_name", "(", "instance", ".", "mode_suffix", "(", ")", ".", "string", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "2", ";", "++", "i", ")", "if", "(", "!", "overloaded_p", "||", "instance", ".", "shape", "->", "explicit_type_suffix_p", "(", "i", ")", ")", "append_name", "(", "instance", ".", "type_suffix", "(", "i", ")", ".", "string", ")", ";", "append_name", "(", "pred_suffixes", "[", "instance", ".", "pred", "]", ")", ";", "return", "finish_name", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "overloaded", "or", "full", "function", "name", "for", "INSTANCE", ";", "OVERLOADED_P", "selects", "which", ".", "Allocate", "the", "string", "on", "m_string_obstack", ";", "the", "caller", "must", "use", "obstack_free", "to", "free", "it", "after", "use", "." ]

[ "aarch64", "\"_offset\"", "\"_index\"", "\"_vnum\"", "0", "2" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "GV", "&&", "!", "GV", "->", "hasInternalLinkage", "(", ")", "&&", "!", "GV", "->", "hasPrivateLinkage", "(", ")", ")", "{", "if", "(", "!", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", "&&", "!", "GV", "->", "isThreadDependent", "(", ")", "&&", "!", "GV", "->", "isThreadLocal", "(", ")", ")", "{", "return", "X86II", "::", "MO_DLLIMPORT", ";", "}", "}", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "GV", ")", "{", "if", "(", "Optional", "<", "ConstantRange", ">", "CR", "=", "GV", "->", "getAbsoluteSymbolRange", "(", ")", ")", "{", "if", "(", "CR", "->", "getUnsignedMax", "(", ")", ".", "ult", "(", "128", ")", ")", "return", "X86II", "::", "MO_ABS8", ";", "else", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "}", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "return", "X86II", "::", "MO_COFFSTUB", ";", "}", "if", "(", "isOSWindows", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "isTargetELF", "(", ")", "?", "X86II", "::", "MO_GOT", ":", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_GOT", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_DLLIMPORT", "X86II::MO_NO_FLAG", "128", "X86II::MO_ABS8", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_COFFSTUB", "X86II::MO_NO_FLAG", "X86II::MO_GOT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i8", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "Hexagon", "::", "IntRegsRegisterClass", ")", ";", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "Hexagon", "::", "DoubleRegsRegisterClass", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unknown asm register class\"", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "Hexagon", "Hexagon", "1", "0", "\"getRegForInlineAsmConstraint Unhandled data type\"", "MVT::i32", "MVT::i16", "MVT::i8", "0U", "Hexagon::IntRegsRegisterClass", "MVT::i64", "0U", "Hexagon::DoubleRegsRegisterClass", "\"Unknown asm register class\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "int", "ConstantBusLimit", "=", "ST", ".", "getConstantBusLimit", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "int", "VOP3LiteralLimit", "=", "ST", ".", "hasVOP3Literal", "(", ")", "?", "1", ":", "0", ";", "if", "(", "isVALU", "(", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "OpInfo", ")", ")", "{", "if", "(", "isVOP3", "(", "MI", ")", "&&", "isLiteralConstantLike", "(", "*", "MO", ",", "OpInfo", ")", "&&", "!", "VOP3LiteralLimit", "--", ")", "return", "false", ";", "SmallDenseSet", "<", "RegSubRegPair", ">", "SGPRsUsed", ";", "if", "(", "MO", "->", "isReg", "(", ")", ")", "SGPRsUsed", ".", "insert", "(", "RegSubRegPair", "(", "MO", "->", "getReg", "(", ")", ",", "MO", "->", "getSubReg", "(", ")", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "==", "OpIdx", ")", "continue", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "RegSubRegPair", "SGPR", "(", "Op", ".", "getReg", "(", ")", ",", "Op", ".", "getSubReg", "(", ")", ")", ";", "if", "(", "!", "SGPRsUsed", ".", "count", "(", "SGPR", ")", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "SGPRsUsed", ".", "insert", "(", "SGPR", ")", ";", "}", "}", "else", "if", "(", "InstDesc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "AMDGPU", "::", "OPERAND_KIMM32", ")", "{", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "}", "else", "if", "(", "isVOP3", "(", "MI", ")", "&&", "AMDGPU", "::", "isSISrcOperand", "(", "InstDesc", ",", "i", ")", "&&", "isLiteralConstantLike", "(", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "if", "(", "!", "VOP3LiteralLimit", "--", ")", "return", "false", ";", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "*", "MO", ")", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", ")", ";", "if", "(", "!", "DefinedRC", ")", "{", "return", "true", ";", "}", "return", "isImmOperandLegal", "(", "MI", ",", "OpIdx", ",", "*", "MO", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "is", "a", "legal", "operand", "if", "it", "was", "the", "OpIdx", "Operand", "for", "MI", "." ]

[ "AMDGPU", "SI", "1", "1", "0", "0", "0", "AMDGPU::OPERAND_KIMM32", "0", "AMDGPU::isSISrcOperand", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "RISCVAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_riscv_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_pcrel_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_i\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_s\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_got_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_tprel_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_tls_got_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_tls_gd_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_jal\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_branch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_jump\"", ",", "2", ",", "11", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_branch\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call_plt\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_relax\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_align\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_loop_setup_5\"", ",", "15", ",", "5", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_loop_setup_12\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "RISCV", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "RISCV", "RISCV", "\"fixup_riscv_hi20\"", "12", "20", "0", "\"fixup_riscv_lo12_i\"", "20", "12", "0", "\"fixup_riscv_lo12_s\"", "0", "32", "0", "\"fixup_riscv_pcrel_hi20\"", "12", "20", "\"fixup_riscv_pcrel_lo12_i\"", "20", "12", "\"fixup_riscv_pcrel_lo12_s\"", "0", "32", "\"fixup_riscv_got_hi20\"", "12", "20", "\"fixup_riscv_tprel_hi20\"", "12", "20", "0", "\"fixup_riscv_tprel_lo12_i\"", "20", "12", "0", "\"fixup_riscv_tprel_lo12_s\"", "0", "32", "0", "\"fixup_riscv_tprel_add\"", "0", "0", "0", "\"fixup_riscv_tls_got_hi20\"", "12", "20", "\"fixup_riscv_tls_gd_hi20\"", "12", "20", "\"fixup_riscv_jal\"", "12", "20", "\"fixup_riscv_branch\"", "0", "32", "\"fixup_riscv_rvc_jump\"", "2", "11", "\"fixup_riscv_rvc_branch\"", "0", "16", "\"fixup_riscv_call\"", "0", "64", "\"fixup_riscv_call_plt\"", "0", "64", "\"fixup_riscv_relax\"", "0", "0", "0", "\"fixup_riscv_align\"", "0", "0", "0", "\"fixup_riscv_loop_setup_5\"", "15", "5", "\"fixup_riscv_loop_setup_12\"", "20", "12", "RISCV::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "void", "mips16_emit_constants", "(", "struct", "mips16_constant", "*", "constants", ",", "rtx_insn", "*", "insn", ")", "{", "int", "label_num", "=", "constants", "?", "CODE_LABEL_NUMBER", "(", "constants", "->", "label", ")", ":", "0", ";", "struct", "mips16_constant", "*", "c", ",", "*", "next", ";", "int", "align", ";", "align", "=", "0", ";", "if", "(", "constants", ")", "insn", "=", "emit_insn_after", "(", "gen_consttable", "(", "GEN_INT", "(", "label_num", ")", ")", ",", "insn", ")", ";", "for", "(", "c", "=", "constants", ";", "c", "!=", "NULL", ";", "c", "=", "next", ")", "{", "if", "(", "align", "<", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ")", "{", "int", "align_log", "=", "floor_log2", "(", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_align", "(", "GEN_INT", "(", "align_log", ")", ")", ",", "insn", ")", ";", "}", "align", "=", "GET_MODE_SIZE", "(", "c", "->", "mode", ")", ";", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "insn", "=", "mips16_emit_constants_1", "(", "c", "->", "mode", ",", "c", "->", "value", ",", "insn", ")", ";", "next", "=", "c", "->", "next", ";", "free", "(", "c", ")", ";", "}", "if", "(", "constants", ")", "insn", "=", "emit_insn_after", "(", "gen_consttable_end", "(", "GEN_INT", "(", "label_num", ")", ")", ",", "insn", ")", ";", "emit_barrier_after", "(", "insn", ")", ";", "}", "</s>" ]

[ "Dump", "out", "the", "constants", "in", "CONSTANTS", "after", "INSN", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "unsigned", "MipsCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getMipsRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "true", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Mips", "Mips", "Mips", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "bool", "PatmosAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", "||", "MBB", "->", "hasAddressTaken", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "if", "(", "++", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "isFStart", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "void", "CJGFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "4", ",", "-", "4", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for FP register must be last in order to be found!\"", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "CJG", "CJG", "4", "4", "\"Slot for FP register must be last in order to be found!\"" ]

[]

[ "<s>", "static", "unsigned", "rs6000_hash_constant", "(", "rtx", "k", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "k", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "k", ")", ";", "unsigned", "result", "=", "(", "code", "<<", "3", ")", "^", "mode", ";", "const", "char", "*", "format", ";", "int", "flen", ",", "fidx", ";", "format", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "flen", "=", "strlen", "(", "format", ")", ";", "fidx", "=", "0", ";", "switch", "(", "code", ")", "{", "case", "LABEL_REF", ":", "return", "result", "*", "1231", "+", "(", "unsigned", ")", "INSN_UID", "(", "XEXP", "(", "k", ",", "0", ")", ")", ";", "case", "CONST_WIDE_INT", ":", "{", "int", "i", ";", "flen", "=", "CONST_WIDE_INT_NUNITS", "(", "k", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "flen", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "CONST_WIDE_INT_ELT", "(", "k", ",", "i", ")", ";", "return", "result", ";", "}", "case", "CONST_DOUBLE", ":", "if", "(", "mode", "!=", "VOIDmode", ")", "return", "real_hash", "(", "CONST_DOUBLE_REAL_VALUE", "(", "k", ")", ")", "*", "result", ";", "flen", "=", "2", ";", "break", ";", "case", "CODE_LABEL", ":", "fidx", "=", "3", ";", "break", ";", "default", ":", "break", ";", "}", "for", "(", ";", "fidx", "<", "flen", ";", "fidx", "++", ")", "switch", "(", "format", "[", "fidx", "]", ")", "{", "case", "'s'", ":", "{", "unsigned", "i", ",", "len", ";", "const", "char", "*", "str", "=", "XSTR", "(", "k", ",", "fidx", ")", ";", "len", "=", "strlen", "(", "str", ")", ";", "result", "=", "result", "*", "613", "+", "len", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "str", "[", "i", "]", ";", "break", ";", "}", "case", "'u'", ":", "case", "'e'", ":", "result", "=", "result", "*", "1231", "+", "rs6000_hash_constant", "(", "XEXP", "(", "k", ",", "fidx", ")", ")", ";", "break", ";", "case", "'i'", ":", "case", "'n'", ":", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "XINT", "(", "k", ",", "fidx", ")", ";", "break", ";", "case", "'w'", ":", "if", "(", "sizeof", "(", "unsigned", ")", ">=", "sizeof", "(", "HOST_WIDE_INT", ")", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "XWINT", "(", "k", ",", "fidx", ")", ";", "else", "{", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "HOST_WIDE_INT", ")", "/", "sizeof", "(", "unsigned", ")", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "(", "XWINT", "(", "k", ",", "fidx", ")", ">>", "CHAR_BIT", "*", "i", ")", ";", "}", "break", ";", "case", "'0'", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Hash", "functions", "for", "the", "hash", "table", "." ]

[ "powerpcspe", "3", "0", "1231", "0", "0", "613", "2", "3", "613", "0", "613", "1231", "613", "613", "0", "613" ]

[]

[ "<s>", "static", "rtx", "c6x_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "cum", "->", "count", ">=", "cum", "->", "nregs", ")", "return", "NULL_RTX", ";", "if", "(", "type", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "size", ">", "4", ")", "{", "rtx", "reg1", "=", "gen_rtx_REG", "(", "SImode", ",", "argument_registers", "[", "cum", "->", "count", "]", "+", "1", ")", ";", "rtx", "reg2", "=", "gen_rtx_REG", "(", "SImode", ",", "argument_registers", "[", "cum", "->", "count", "]", ")", ";", "rtvec", "vec", "=", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg1", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg2", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "vec", ")", ";", "}", "}", "}", "return", "gen_rtx_REG", "(", "mode", ",", "argument_registers", "[", "cum", "->", "count", "]", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "FUNCTION_ARG", "defined", "in", "c6x.h", "." ]

[ "c6x", "4", "1", "2", "4" ]

[]

[ "<s>", "static", "inline", "bool", "mode_supports_vmx_dform", "(", "machine_mode", "mode", ")", "{", "return", "(", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_VMX", "]", "&", "RELOAD_REG_OFFSET", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "have", "D-form", "addressing", "in", "altivec", "registers", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "MCSymbol", "*", "M68kMCInstLower", "::", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "assert", "(", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isMBB", "(", ")", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "const", "auto", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", "&&", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "return", "AsmPrinter", ".", "getSymbolPreferLocal", "(", "*", "MO", ".", "getGlobal", "(", ")", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "nullptr", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "AsmPrinter", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "assert", "(", "Suffix", ".", "empty", "(", ")", ")", ";", "Sym", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "}", "Name", "+=", "Suffix", ";", "if", "(", "!", "Sym", ")", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "M68k", "M68k", "\"Isn't a symbol reference\"", "128" ]

[]

[ "<s>", "int", "includes_rldicr_lshift_p", "(", "rtx", "shiftop", ",", "rtx", "andop", ")", "{", "if", "(", "GET_CODE", "(", "andop", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "c", ",", "lsb", ",", "shift_mask", ";", "shift_mask", "=", "HOST_WIDE_INT_M1U", ";", "shift_mask", "<<=", "INTVAL", "(", "shiftop", ")", ";", "c", "=", "INTVAL", "(", "andop", ")", ";", "lsb", "=", "c", "&", "-", "c", ";", "if", "(", "(", "lsb", "&", "shift_mask", ")", "==", "0", ")", "return", "0", ";", "return", "c", "==", "-", "lsb", "&&", "lsb", "!=", "1", ";", "}", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "ANDOP", "is", "a", "mask", "suitable", "for", "use", "with", "an", "rldicr", "insn", "to", "perform", "a", "left", "shift", ".", "It", "must", "have", "SHIFTOP", "or", "more", "least", "significant", "0", "'s", ",", "with", "the", "remainder", "of", "the", "word", "1", "'s", "." ]

[ "rs6000", "0", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "SPILL_CR", ":", "case", "PPC", "::", "SPILL_CRBIT", ":", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "STXV", ":", "case", "PPC", "::", "QVSTFDX", ":", "case", "PPC", "::", "QVSTFSXs", ":", "case", "PPC", "::", "QVSTFDXb", ":", "case", "PPC", "::", "SPILL_VRSAVE", ":", "case", "PPC", "::", "SPILLTOVSR_ST", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "PPC::SPILL_CR", "PPC::SPILL_CRBIT", "PPC::STVX", "PPC::STXVD2X", "PPC::STXV", "PPC::QVSTFDX", "PPC::QVSTFSXs", "PPC::QVSTFDXb", "PPC::SPILL_VRSAVE", "PPC::SPILLTOVSR_ST", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "static", "bool", "use_real_merge_p", "(", "enum", "predication_type_index", "pred", ")", "{", "return", "pred", "==", "PRED_TYPE_tu", "||", "pred", "==", "PRED_TYPE_tum", "||", "pred", "==", "PRED_TYPE_tumu", "||", "pred", "==", "PRED_TYPE_mu", ";", "}", "</s>" ]

[ "Return", "true", "if", "predication", "is", "using", "a", "real", "merge", "operand", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "PM", ".", "add", "(", "createHexagonCFGOptimizer", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "bool", "Vector", "=", "(", "ClassID", "==", "1", ")", ";", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "32", ";", "return", "0", ";", "}", "return", "31", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "AArch64", "1", "32", "0", "31" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "LowerToMovInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "if", "(", "ST", "->", "isWave32", "(", ")", ")", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B32", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B32_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ";", "Exec", "=", "AMDGPU", "::", "EXEC_LO", ";", "}", "else", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B64", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B64_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "Exec", "=", "AMDGPU", "::", "EXEC", ";", "}", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "Exec", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", "&&", "LowerToCopyInstrs", ".", "empty", "(", ")", "&&", "LowerToMovInstrs", ".", "empty", "(", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "TRI", "->", "getBoolRC", "(", ")", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "Exec", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "auto", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_WQM_B32", ":", "AMDGPU", "::", "S_WQM_B64", ")", ",", "Exec", ")", ".", "addReg", "(", "Exec", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "LLVM_DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "if", "(", "LiveMaskReg", ")", "LIS", "->", "createAndComputeVirtRegInterval", "(", "LiveMaskReg", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_AND_B32", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_SAVEEXEC_B32", "AMDGPU::EXEC_LO", "AMDGPU::S_AND_B64", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_SAVEEXEC_B64", "AMDGPU::EXEC", "0", "AMDGPU::COPY", "AMDGPU::S_WQM_B32", "AMDGPU::S_WQM_B64", "AMDGPU::SCC" ]

[]

[ "<s>", "Align", "SITargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "const", "Align", "PrefAlign", "=", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "const", "Align", "CacheLineAlign", "=", "Align", "(", "64", ")", ";", "if", "(", "!", "ML", "||", "DisableLoopAlignment", "||", "(", "getSubtarget", "(", ")", "->", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "GFX10", ")", "||", "getSubtarget", "(", ")", "->", "hasInstFwdPrefetchBug", "(", ")", ")", "return", "PrefAlign", ";", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "const", "MachineBasicBlock", "*", "Header", "=", "ML", "->", "getHeader", "(", ")", ";", "if", "(", "Header", "->", "getAlignment", "(", ")", "!=", "PrefAlign", ")", "return", "Header", "->", "getAlignment", "(", ")", ";", "unsigned", "LoopSize", "=", "0", ";", "for", "(", "const", "MachineBasicBlock", "*", "MBB", ":", "ML", "->", "blocks", "(", ")", ")", "{", "if", "(", "MBB", "!=", "Header", ")", "LoopSize", "+=", "MBB", "->", "getAlignment", "(", ")", ".", "value", "(", ")", "/", "2", ";", "for", "(", "const", "MachineInstr", "&", "MI", ":", "*", "MBB", ")", "{", "LoopSize", "+=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "if", "(", "LoopSize", ">", "192", ")", "return", "PrefAlign", ";", "}", "}", "if", "(", "LoopSize", "<=", "64", ")", "return", "PrefAlign", ";", "if", "(", "LoopSize", "<=", "128", ")", "return", "CacheLineAlign", ";", "for", "(", "MachineLoop", "*", "P", "=", "ML", "->", "getParentLoop", "(", ")", ";", "P", ";", "P", "=", "P", "->", "getParentLoop", "(", ")", ")", "{", "if", "(", "MachineBasicBlock", "*", "Exit", "=", "P", "->", "getExitBlock", "(", ")", ")", "{", "auto", "I", "=", "Exit", "->", "getFirstNonDebugInstr", "(", ")", ";", "if", "(", "I", "!=", "Exit", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_INST_PREFETCH", ")", "return", "CacheLineAlign", ";", "}", "}", "MachineBasicBlock", "*", "Pre", "=", "ML", "->", "getLoopPreheader", "(", ")", ";", "MachineBasicBlock", "*", "Exit", "=", "ML", "->", "getExitBlock", "(", ")", ";", "if", "(", "Pre", "&&", "Exit", ")", "{", "auto", "PreTerm", "=", "Pre", "->", "getFirstTerminator", "(", ")", ";", "if", "(", "PreTerm", "==", "Pre", "->", "begin", "(", ")", "||", "std", "::", "prev", "(", "PreTerm", ")", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "S_INST_PREFETCH", ")", "BuildMI", "(", "*", "Pre", ",", "PreTerm", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_INST_PREFETCH", ")", ")", ".", "addImm", "(", "1", ")", ";", "auto", "ExitHead", "=", "Exit", "->", "getFirstNonDebugInstr", "(", ")", ";", "if", "(", "ExitHead", "==", "Exit", "->", "end", "(", ")", "||", "ExitHead", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "S_INST_PREFETCH", ")", "BuildMI", "(", "*", "Exit", ",", "ExitHead", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_INST_PREFETCH", ")", ")", ".", "addImm", "(", "2", ")", ";", "}", "return", "CacheLineAlign", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "AMDGPU", "SI", "64", "AMDGPU", "SI", "0", "2", "192", "64", "128", "AMDGPU::S_INST_PREFETCH", "AMDGPU::S_INST_PREFETCH", "AMDGPU::S_INST_PREFETCH", "1", "AMDGPU::S_INST_PREFETCH", "AMDGPU::S_INST_PREFETCH", "2" ]

[]

[ "<s>", "const", "MipsInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"XCore DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "XCore", "\"XCore DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "machine_mode", "s390_preferred_simd_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_VX", ")", "switch", "(", "mode", ")", "{", "case", "DFmode", ":", "return", "V2DFmode", ";", "case", "DImode", ":", "return", "V2DImode", ";", "case", "SImode", ":", "return", "V4SImode", ";", "case", "HImode", ":", "return", "V8HImode", ";", "case", "QImode", ":", "return", "V16QImode", ";", "default", ":", ";", "}", "return", "word_mode", ";", "}", "</s>" ]

[ "Return", "the", "vector", "mode", "to", "be", "used", "for", "inner", "mode", "MODE", "when", "doing", "vectorization", "." ]

[ "s390" ]

[]

[ "<s>", "const", "XtensaSubtarget", "*", "XtensaTargetMachine", "::", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "Xtensa" ]

[]

[ "<s>", "static", "bool", "tilepro_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "return", "true", ";", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "push", "(", "const", "Candidate", "&&", "C", ")", "{", "if", "(", "C", ".", "Weight", ")", "push_back", "(", "C", ")", ";", "else", "push_front", "(", "C", ")", ";", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "LC2200TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "LC2200ISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "LC2200ISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "LC2200ISD", "::", "RET", ":", "return", "\"LC2200ISD::RET\"", ";", "case", "LC2200ISD", "::", "CALL", ":", "return", "\"LC2200ISD::CALL\"", ";", "case", "LC2200ISD", "::", "JMP", ":", "return", "\"LC2200ISD::JMP\"", ";", "case", "LC2200ISD", "::", "NAND", ":", "return", "\"LC2200ISD::NAND\"", ";", "case", "LC2200ISD", "::", "CMP_SKIP", ":", "return", "\"LC2200ISD::CMP_SKIP\"", ";", "case", "LC2200ISD", "::", "CMP_JMP", ":", "return", "\"LC2200ISD::CMP_JMP\"", ";", "case", "LC2200ISD", "::", "SELECT_MOVE", ":", "return", "\"LC2200ISD::SELECT_MOVE\"", ";", "case", "LC2200ISD", "::", "CMP_SELECT_MOVE", ":", "return", "\"LC2200ISD::CMP_SELECT_MOVE\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200ISD::NodeType", "LC2200ISD::FIRST_NUMBER", "LC2200ISD::RET", "\"LC2200ISD::RET\"", "LC2200ISD::CALL", "\"LC2200ISD::CALL\"", "LC2200ISD::JMP", "\"LC2200ISD::JMP\"", "LC2200ISD::NAND", "\"LC2200ISD::NAND\"", "LC2200ISD::CMP_SKIP", "\"LC2200ISD::CMP_SKIP\"", "LC2200ISD::CMP_JMP", "\"LC2200ISD::CMP_JMP\"", "LC2200ISD::SELECT_MOVE", "\"LC2200ISD::SELECT_MOVE\"", "LC2200ISD::CMP_SELECT_MOVE", "\"LC2200ISD::CMP_SELECT_MOVE\"" ]

[]

[ "<s>", "static", "bool", "frv_must_pass_in_stack", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "mode", "==", "BLKmode", ")", "return", "true", ";", "if", "(", "type", "==", "NULL", ")", "return", "false", ";", "return", "AGGREGATE_TYPE_P", "(", "type", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "should", "pass", "an", "argument", "on", "the", "stack", "rather", "than", "in", "registers", "." ]

[ "frv" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "STI", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SwiftError_RegMask", ":", "CSR_AAPCS_SwiftError_RegMask", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "CSR_iOS_CXX_TLS_RegMask", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getDarwinDirective", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "case", "PPC", "::", "DIR_PWR9", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "{", "LoopSize", "+=", "TII", "->", "GetInstSizeInBytes", "(", "J", ")", ";", "if", "(", "LoopSize", ">", "32", ")", "break", ";", "}", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "5", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::DIR_970", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "PPC", "0", "32", "16", "32", "5" ]

[]