Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "MF", "->", "begin", "(", ")", ",", "E", "=", "MF", "->", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "MBBI", ";", "unsigned", "MBBId", "=", "MBB", "->", "getNumber", "(", ")", ";", "assert", "(", "!", "MBBId", "||", "BBInfo", "[", "MBBId", "-", "1", "]", ".", "postOffset", "(", ")", "<=", "BBInfo", "[", "MBBId", "]", ".", "Offset", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Verifying \"", "<<", "CPUsers", ".", "size", "(", ")", "<<", "\" CP users.\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "getUserOffset", "(", "U", ")", ";", "if", "(", "isCPEntryInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "U", ".", "getMaxDisp", "(", ")", "+", "2", ",", "U", ".", "NegOk", ",", "true", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"OK\\n\"", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Out of range.\\n\"", ")", ";", "dumpBBs", "(", ")", ";", "DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM", "ARM", "1", "\"Verifying \"", "\" CP users.\\n\"", "0", "2", "\"OK\\n\"", "\"Out of range.\\n\"", "\"Constant pool entry out of range!\"" ]

[]

[ "<s>", "void", "s390_expand_cs_hqi", "(", "machine_mode", "mode", ",", "rtx", "btarget", ",", "rtx", "vtarget", ",", "rtx", "mem", ",", "rtx", "cmp", ",", "rtx", "new_rtx", ",", "bool", "is_weak", ")", "{", "struct", "alignment_context", "ac", ";", "rtx", "cmpv", ",", "newv", ",", "val", ",", "cc", ",", "seq0", ",", "seq1", ",", "seq2", ",", "seq3", ";", "rtx", "res", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "csloop", "=", "NULL", ",", "*", "csend", "=", "NULL", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ",", "mode", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "ac", ".", "memsi", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cmpv", "=", "s390_two_part_insv", "(", "&", "ac", ",", "&", "seq0", ",", "&", "seq2", ",", "mode", ",", "val", ",", "cmp", ")", ";", "newv", "=", "s390_two_part_insv", "(", "&", "ac", ",", "&", "seq1", ",", "&", "seq3", ",", "mode", ",", "val", ",", "new_rtx", ")", ";", "if", "(", "seq0", ")", "emit_insn", "(", "seq0", ")", ";", "if", "(", "seq1", ")", "emit_insn", "(", "seq1", ")", ";", "if", "(", "!", "is_weak", ")", "{", "emit_move_insn", "(", "btarget", ",", "const1_rtx", ")", ";", "csloop", "=", "gen_label_rtx", "(", ")", ";", "csend", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "csloop", ")", ";", "}", "emit_insn", "(", "seq2", ")", ";", "emit_insn", "(", "seq3", ")", ";", "cc", "=", "s390_emit_compare_and_swap", "(", "EQ", ",", "res", ",", "ac", ".", "memsi", ",", "cmpv", ",", "newv", ")", ";", "if", "(", "is_weak", ")", "emit_insn", "(", "gen_cstorecc4", "(", "btarget", ",", "cc", ",", "XEXP", "(", "cc", ",", "0", ")", ",", "XEXP", "(", "cc", ",", "1", ")", ")", ")", ";", "else", "{", "rtx", "tmp", ";", "s390_emit_jump", "(", "csend", ",", "cc", ")", ";", "tmp", "=", "copy_to_reg", "(", "val", ")", ";", "force_expand_binop", "(", "SImode", ",", "and_optab", ",", "res", ",", "ac", ".", "modemaski", ",", "val", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cc", "=", "s390_emit_compare", "(", "NE", ",", "val", ",", "tmp", ")", ";", "s390_emit_jump", "(", "csloop", ",", "cc", ")", ";", "emit_move_insn", "(", "btarget", ",", "const0_rtx", ")", ";", "emit_label", "(", "csend", ")", ";", "}", "convert_move", "(", "vtarget", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "res", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ",", "1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "compare", "and", "swap", "operation", "for", "HImode", "and", "QImode", ".", "MEM", "is", "the", "memory", "location", ",", "CMP", "the", "old", "value", "to", "compare", "MEM", "with", "and", "NEW", "the", "value", "to", "set", "if", "CMP", "==", "MEM", ".", "CMP", "is", "never", "in", "memory", "for", "compare_and_swap_cc", "because", "expand_bool_compare_and_swap", "puts", "it", "into", "a", "register", "for", "later", "compare", "." ]

[ "s390", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "tree", "m68hc11_handle_fntype_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "METHOD_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "FIELD_DECL", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "TYPE_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "attribute", "requiring", "a", "FUNCTION_TYPE", ",", "FIELD_DECL", "or", "TYPE_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "m68hc11", "\"%qs attribute only applies to functions\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedBits", ",", "const", "APInt", "&", "DemandedElts", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "int", "NumElts", "=", "DemandedElts", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "X86ISD", "::", "PINSRB", ":", "case", "X86ISD", "::", "PINSRW", ":", "{", "SDValue", "Vec", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "auto", "*", "CIdx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "MVT", "VecVT", "=", "Vec", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "CIdx", "&&", "CIdx", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "VecVT", ".", "getVectorNumElements", "(", ")", ")", "&&", "!", "DemandedElts", "[", "CIdx", "->", "getZExtValue", "(", ")", "]", ")", "return", "Vec", ";", "break", ";", "}", "case", "X86ISD", "::", "PCMPGT", ":", "if", "(", "DemandedBits", ".", "isSignMask", "(", ")", "&&", "ISD", "::", "isBuildVectorAllZeros", "(", "Op", ".", "getOperand", "(", "0", ")", ".", "getNode", "(", ")", ")", ")", "return", "Op", ".", "getOperand", "(", "1", ")", ";", "break", ";", "}", "APInt", "ShuffleUndef", ",", "ShuffleZero", ";", "SmallVector", "<", "int", ",", "16", ">", "ShuffleMask", ";", "SmallVector", "<", "SDValue", ",", "2", ">", "ShuffleOps", ";", "if", "(", "getTargetShuffleInputs", "(", "Op", ",", "DemandedElts", ",", "ShuffleOps", ",", "ShuffleMask", ",", "ShuffleUndef", ",", "ShuffleZero", ",", "DAG", ",", "Depth", ",", "false", ")", ")", "{", "int", "NumOps", "=", "ShuffleOps", ".", "size", "(", ")", ";", "if", "(", "ShuffleMask", ".", "size", "(", ")", "==", "(", "unsigned", ")", "NumElts", "&&", "llvm", "::", "all_of", "(", "ShuffleOps", ",", "[", "VT", "]", "(", "SDValue", "V", ")", "{", "return", "VT", ".", "getSizeInBits", "(", ")", "==", "V", ".", "getValueSizeInBits", "(", ")", ";", "}", ")", ")", "{", "if", "(", "DemandedElts", ".", "isSubsetOf", "(", "ShuffleUndef", ")", ")", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "if", "(", "DemandedElts", ".", "isSubsetOf", "(", "ShuffleUndef", "|", "ShuffleZero", ")", ")", "return", "getZeroVector", "(", "VT", ".", "getSimpleVT", "(", ")", ",", "Subtarget", ",", "DAG", ",", "SDLoc", "(", "Op", ")", ")", ";", "APInt", "IdentityOp", "=", "APInt", "::", "getAllOnesValue", "(", "NumOps", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "int", "M", "=", "ShuffleMask", "[", "i", "]", ";", "if", "(", "!", "DemandedElts", "[", "i", "]", "||", "ShuffleUndef", "[", "i", "]", ")", "continue", ";", "int", "Op", "=", "M", "/", "NumElts", ";", "int", "Index", "=", "M", "%", "NumElts", ";", "if", "(", "M", "<", "0", "||", "Index", "!=", "i", ")", "{", "IdentityOp", ".", "clearAllBits", "(", ")", ";", "break", ";", "}", "IdentityOp", "&=", "APInt", "::", "getOneBitSet", "(", "NumOps", ",", "Op", ")", ";", "if", "(", "IdentityOp", "==", "0", ")", "break", ";", "}", "assert", "(", "(", "IdentityOp", "==", "0", "||", "IdentityOp", ".", "countPopulation", "(", ")", "==", "1", ")", "&&", "\"Multiple identity shuffles detected\"", ")", ";", "if", "(", "IdentityOp", "!=", "0", ")", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "ShuffleOps", "[", "IdentityOp", ".", "countTrailingZeros", "(", ")", "]", ")", ";", "}", "}", "return", "TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "Op", ",", "DemandedBits", ",", "DemandedElts", ",", "DAG", ",", "Depth", ")", ";", "}", "</s>" ]

[ "More", "limited", "version", "of", "SimplifyDemandedBits", "that", "can", "be", "used", "to", "``", "look", "through", "''", "ops", "that", "do", "n't", "contribute", "to", "the", "DemandedBits/DemandedElts", "-", "bitwise", "ops", "etc", "." ]

[ "X86", "X86", "X86ISD::PINSRB", "X86ISD::PINSRW", "0", "2", "X86ISD::PCMPGT", "ISD::isBuildVectorAllZeros", "0", "1", "16", "2", "0", "0", "0", "0", "1", "\"Multiple identity shuffles detected\"", "0" ]

[]

[ "<s>", "bool", "ARMCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", "||", "DisableCGP", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM CGP: Running on \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "auto", "&", "Insts", "=", "BB", ".", "getInstList", "(", ")", ";", "for", "(", "auto", "&", "I", ":", "Insts", ")", "{", "if", "(", "AllVisited", ".", "count", "(", "&", "I", ")", ")", "continue", ";", "if", "(", "isa", "<", "ICmpInst", ">", "(", "I", ")", ")", "{", "auto", "&", "CI", "=", "cast", "<", "ICmpInst", ">", "(", "I", ")", ";", "if", "(", "CI", ".", "isSigned", "(", ")", "||", "!", "isa", "<", "IntegerType", ">", "(", "CI", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM CGP: Searching from: \"", "<<", "CI", "<<", "\"\\n\"", ")", ";", "for", "(", "auto", "&", "Op", ":", "CI", ".", "operands", "(", ")", ")", "{", "if", "(", "auto", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "Op", ")", ")", "MadeChange", "|=", "TryToPromote", "(", "I", ")", ";", "}", "}", "}", "Promoter", "->", "Cleanup", "(", ")", ";", "LLVM_DEBUG", "(", "if", "(", "verifyFunction", "(", "F", ",", "&", "dbgs", "(", ")", ")", ")", "{", "dbgs", "(", ")", ";", "report_fatal_error", "(", "\"Broken function after type promotion\"", ")", ";", "}", ")", ";", "}", "if", "(", "MadeChange", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"After ARMCodeGenPrepare: \"", "<<", "F", "<<", "\"\\n\"", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "ARM", "ARM", "ARM", "\"ARM CGP: Running on \"", "\"\\n\"", "0", "\"ARM CGP: Searching from: \"", "\"\\n\"", "\"Broken function after type promotion\"", "\"After ARMCodeGenPrepare: \"", "\"\\n\"" ]

[]

[ "<s>", "static", "const", "char", "*", "ix86_get_multilib_abi_name", "(", "void", ")", "{", "if", "(", "!", "(", "TARGET_64BIT_P", "(", "ix86_isa_flags", ")", ")", ")", "return", "\"i386\"", ";", "else", "if", "(", "TARGET_X32_P", "(", "ix86_isa_flags", ")", ")", "return", "\"x32\"", ";", "else", "return", "\"x86_64\"", ";", "}", "</s>" ]

[ "This", "hook", "returns", "name", "of", "multilib", "ABI", "." ]

[ "i386", "\"i386\"", "\"x32\"", "\"x86_64\"" ]

[]

[ "<s>", "void", "nvptx_expand_call", "(", "rtx", "retval", ",", "rtx", "address", ")", "{", "rtx", "callee", "=", "XEXP", "(", "address", ",", "0", ")", ";", "rtx", "varargs", "=", "NULL_RTX", ";", "unsigned", "parallel", "=", "0", ";", "if", "(", "!", "call_insn_operand", "(", "callee", ",", "Pmode", ")", ")", "{", "callee", "=", "force_reg", "(", "Pmode", ",", "callee", ")", ";", "address", "=", "change_address", "(", "address", ",", "QImode", ",", "callee", ")", ";", "}", "if", "(", "GET_CODE", "(", "callee", ")", "==", "SYMBOL_REF", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "callee", ")", ";", "if", "(", "decl", "!=", "NULL_TREE", ")", "{", "if", "(", "DECL_STATIC_CHAIN", "(", "decl", ")", ")", "cfun", "->", "machine", "->", "has_chain", "=", "true", ";", "tree", "attr", "=", "get_oacc_fn_attrib", "(", "decl", ")", ";", "if", "(", "attr", ")", "{", "tree", "dims", "=", "TREE_VALUE", "(", "attr", ")", ";", "parallel", "=", "GOMP_DIM_MASK", "(", "GOMP_DIM_MAX", ")", "-", "1", ";", "for", "(", "int", "ix", "=", "0", ";", "ix", "!=", "GOMP_DIM_MAX", ";", "ix", "++", ")", "{", "if", "(", "TREE_PURPOSE", "(", "dims", ")", "&&", "!", "integer_zerop", "(", "TREE_PURPOSE", "(", "dims", ")", ")", ")", "break", ";", "parallel", "^=", "GOMP_DIM_MASK", "(", "ix", ")", ";", "dims", "=", "TREE_CHAIN", "(", "dims", ")", ";", "}", "}", "}", "}", "unsigned", "nargs", "=", "cfun", "->", "machine", "->", "num_args", ";", "if", "(", "cfun", "->", "machine", "->", "is_varadic", ")", "{", "varargs", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "varargs", ",", "stack_pointer_rtx", ")", ";", "}", "rtvec", "vec", "=", "rtvec_alloc", "(", "nargs", "+", "1", ")", ";", "rtx", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "int", "vec_pos", "=", "0", ";", "rtx", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "address", ",", "const0_rtx", ")", ";", "rtx", "tmp_retval", "=", "retval", ";", "if", "(", "retval", ")", "{", "if", "(", "!", "nvptx_register_operand", "(", "retval", ",", "GET_MODE", "(", "retval", ")", ")", ")", "tmp_retval", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "retval", ")", ")", ";", "call", "=", "gen_rtx_SET", "(", "tmp_retval", ",", "call", ")", ";", "}", "XVECEXP", "(", "pat", ",", "0", ",", "vec_pos", "++", ")", "=", "call", ";", "for", "(", "rtx", "arg", "=", "cfun", "->", "machine", "->", "call_args", ";", "arg", ";", "arg", "=", "XEXP", "(", "arg", ",", "1", ")", ")", "XVECEXP", "(", "pat", ",", "0", ",", "vec_pos", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "XEXP", "(", "arg", ",", "0", ")", ")", ";", "if", "(", "varargs", ")", "XVECEXP", "(", "pat", ",", "0", ",", "vec_pos", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "varargs", ")", ";", "gcc_assert", "(", "vec_pos", "=", "XVECLEN", "(", "pat", ",", "0", ")", ")", ";", "nvptx_emit_forking", "(", "parallel", ",", "true", ")", ";", "emit_call_insn", "(", "pat", ")", ";", "nvptx_emit_joining", "(", "parallel", ",", "true", ")", ";", "if", "(", "tmp_retval", "!=", "retval", ")", "emit_move_insn", "(", "retval", ",", "tmp_retval", ")", ";", "}", "</s>" ]

[ "Emit", "the", "sequence", "for", "a", "call", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "R600", "0" ]

[]

[ "<s>", "rtx", "loongarch_strip_unspec_address", "(", "rtx", "op", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "op", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "base", ")", ")", "op", "=", "plus_constant", "(", "Pmode", ",", "UNSPEC_ADDRESS", "(", "base", ")", ",", "INTVAL", "(", "offset", ")", ")", ";", "return", "op", ";", "}", "</s>" ]

[ "If", "OP", "is", "an", "UNSPEC", "address", ",", "return", "the", "address", "to", "which", "it", "refers", ",", "otherwise", "return", "OP", "itself", "." ]

[ "loongarch" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"RISCV sext.w Removal\"", ";", "}", "</s>" ]

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

[ "RISCV", "\"RISCV sext.w Removal\"" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_kernel\"", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_amdgpu_isa\"", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"", "\".amdgpu_hsa_kernel\"", "AMDGPU", "\".amd_amdgpu_isa\"", "AMDGPU::HSAMD" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "unsigned", "Size", "=", "LI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", "!=", "128", "||", "isOpSuitableForLDPSTP", "(", "LI", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "AArch64", "AArch64", "128" ]

[]

[ "<s>", "const", "char", "*", "output_mov_double_fpa_from_arm", "(", "rtx", "*", "operands", ")", "{", "int", "arm_reg0", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "rtx", "ops", "[", "2", "]", ";", "gcc_assert", "(", "arm_reg0", "!=", "IP_REGNUM", ")", ";", "ops", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "arm_reg0", ")", ";", "ops", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "1", "+", "arm_reg0", ")", ";", "output_asm_insn", "(", "\"stm%?fd\\t%|sp!, {%0, %1}\"", ",", "ops", ")", ";", "output_asm_insn", "(", "\"ldf%?d\\t%0, [%|sp], #8\"", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "move", "from", "arm", "registers", "to", "an", "fpa", "registers", ".", "OPERANDS", "[", "0", "]", "is", "an", "fpa", "register", ".", "OPERANDS", "[", "1", "]", "is", "the", "first", "registers", "of", "an", "arm", "register", "pair", "." ]

[ "arm", "1", "2", "0", "1", "1", "\"stm%?fd\\t%|sp!, {%0, %1}\"", "\"ldf%?d\\t%0, [%|sp], #8\"", "\"\"" ]

[]

[ "<s>", "int", "m32c_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "ofs", "=", "0", ";", "if", "(", "from", "==", "AP_REGNO", ")", "{", "if", "(", "TARGET_A16", ")", "ofs", "+=", "5", ";", "else", "ofs", "+=", "8", ";", "}", "if", "(", "to", "==", "SP_REGNO", ")", "{", "ofs", "+=", "m32c_pushm_popm", "(", "PP_justcount", ")", ";", "ofs", "+=", "get_frame_size", "(", ")", ";", "}", "if", "(", "TARGET_A24", ")", "ofs", "=", "(", "ofs", "+", "1", ")", "&", "~", "1", ";", "fprintf", "(", "stderr", ",", "\"initial_elimination_offset from=%d to=%d, ofs=%d\\n\"", ",", "from", ",", "to", ",", "ofs", ")", ";", "return", "ofs", ";", "}", "</s>" ]

[ "Implements", "INITIAL_ELIMINATION_OFFSET", ".", "See", "the", "comment", "above", "that", "diagrams", "our", "call", "frame", "." ]

[ "m32c", "0", "5", "8", "1", "1", "\"initial_elimination_offset from=%d to=%d, ofs=%d\\n\"" ]

[]

[ "<s>", "const", "char", "*", "GBZ80TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "GBISD", "::", "name", ":", "\\", "return", "#", "name", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE", "(", "RET_FLAG", ")", ";", "NODE", "(", "RETI_FLAG", ")", ";", "NODE", "(", "CALL", ")", ";", "NODE", "(", "WRAPPER", ")", ";", "NODE", "(", "FI", ")", ";", "NODE", "(", "LSL", ")", ";", "NODE", "(", "LSR", ")", ";", "NODE", "(", "ROL", ")", ";", "NODE", "(", "ROR", ")", ";", "NODE", "(", "ASR", ")", ";", "NODE", "(", "LSLLOOP", ")", ";", "NODE", "(", "LSRLOOP", ")", ";", "NODE", "(", "ASRLOOP", ")", ";", "NODE", "(", "BRCOND", ")", ";", "NODE", "(", "CMP", ")", ";", "NODE", "(", "CMPC", ")", ";", "NODE", "(", "TST", ")", ";", "NODE", "(", "SELECT_CC", ")", ";", "NODE", "(", "SELECT_BR", ")", ";", "NODE", "(", "BR16", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GBISD::name" ]

[]

[ "<s>", "static", "bool", "i386_pe_dllexport_p", "(", "tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"dllexport\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "return", "true", ";", "if", "(", "associated_type", "(", "decl", ")", "&&", "lookup_attribute", "(", "\"dllexport\"", ",", "TYPE_ATTRIBUTES", "(", "associated_type", "(", "decl", ")", ")", ")", ")", "return", "i386_pe_type_dllexport_p", "(", "decl", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "DECL", "is", "a", "dllexport", "'d", "object", "." ]

[ "i386", "\"dllexport\"", "\"dllexport\"" ]

[]

[ "<s>", "unsigned", "OutgoingValueHandler", "::", "getStackAddress", "(", "const", "CCValAssign", "&", "VA", ",", "MachineMemOperand", "*", "&", "MMO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "unsigned", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "Mips", "::", "SP", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "s32", ")", ";", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "OffsetReg", ",", "Offset", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildGEP", "(", "AddrReg", ",", "SPReg", ",", "OffsetReg", ")", ";", "MachinePointerInfo", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Offset", ")", ";", "unsigned", "Size", "=", "alignTo", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ",", "8", ")", "/", "8", ";", "unsigned", "Align", "=", "MinAlign", "(", "TFL", "->", "getStackAlignment", "(", ")", ",", "Offset", ")", ";", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "Mips", "0", "32", "32", "Mips::SP", "8", "8" ]

[]

[ "<s>", "rtx", "alpha_expand_zap_mask", "(", "HOST_WIDE_INT", "value", ")", "{", "rtx", "result", ";", "int", "i", ";", "HOST_WIDE_INT", "mask", "=", "0", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "mask", "<<=", "8", ";", "if", "(", "!", "(", "(", "value", ">>", "i", ")", "&", "1", ")", ")", "mask", "|=", "0xff", ";", "}", "result", "=", "gen_int_mode", "(", "mask", ",", "DImode", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Returns", "a", "mask", "so", "that", "zap", "(", "x", ",", "value", ")", "==", "x", "&", "mask", "." ]

[ "alpha", "0", "7", "0", "8", "1", "0xff" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "has_vector_insn", "(", "function", "*", "fn", ")", "{", "basic_block", "cfg_bb", ";", "rtx_insn", "*", "rinsn", ";", "FOR_ALL_BB_FN", "(", "cfg_bb", ",", "fn", ")", "FOR_BB_INSNS", "(", "cfg_bb", ",", "rinsn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "rinsn", ")", "&&", "has_vtype_op", "(", "rinsn", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "FN", "has", "a", "vector", "instruction", "that", "use", "VL/VTYPE", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "rtx", "riscv_pass_fpr_single", "(", "machine_mode", "type_mode", ",", "unsigned", "regno", ",", "machine_mode", "value_mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "x", "=", "gen_rtx_REG", "(", "value_mode", ",", "regno", ")", ";", "if", "(", "type_mode", "!=", "value_mode", ")", "{", "x", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "x", ",", "GEN_INT", "(", "offset", ")", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "type_mode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Return", "the", "representation", "of", "an", "argument", "passed", "or", "returned", "in", "an", "FPR", "when", "the", "value", "has", "mode", "VALUE_MODE", "and", "the", "type", "has", "TYPE_MODE", ".", "The", "two", "modes", "may", "be", "different", "for", "structures", "like", ":", "struct", "__attribute__", "(", "(", "packed", ")", ")", "foo", "{", "float", "f", ";", "}", "where", "the", "SFmode", "value", "``", "f", "''", "is", "passed", "in", "REGNO", "but", "the", "struct", "itself", "has", "mode", "BLKmode", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "bool", "ARM64PromoteConstant", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "LocalChange", "=", "false", ";", "SmallSet", "<", "Constant", "*", ",", "8", ">", "AlreadyChecked", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "OpIdx", "=", "0", ",", "EndOpIdx", "=", "MI", ".", "getNumOperands", "(", ")", ";", "OpIdx", "!=", "EndOpIdx", ";", "++", "OpIdx", ")", "{", "Constant", "*", "Cst", "=", "dyn_cast", "<", "Constant", ">", "(", "MI", ".", "getOperand", "(", "OpIdx", ")", ")", ";", "if", "(", "Cst", "&&", "!", "isa", "<", "GlobalValue", ">", "(", "Cst", ")", "&&", "!", "isa", "<", "ConstantExpr", ">", "(", "Cst", ")", "&&", "AlreadyChecked", ".", "insert", "(", "Cst", ")", ")", "LocalChange", "|=", "promoteConstant", "(", "Cst", ")", ";", "}", "}", "}", "return", "LocalChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "ARM64", "ARM64", "8", "0" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", ")", "const", "{", "if", "(", "LdSt", ".", "getNumOperands", "(", ")", "!=", "4", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "||", "!", "(", "LdSt", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "LdSt", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "LPAC", "::", "ADD", ")", ")", "return", "false", ";", "switch", "(", "LdSt", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Lanai", "::", "LDW_RI", ":", "case", "Lanai", "::", "LDW_RR", ":", "case", "Lanai", "::", "SW_RR", ":", "case", "Lanai", "::", "SW_RI", ":", "Width", "=", "4", ";", "break", ";", "case", "Lanai", "::", "LDHs_RI", ":", "case", "Lanai", "::", "LDHz_RI", ":", "case", "Lanai", "::", "STH_RI", ":", "Width", "=", "2", ";", "break", ";", "case", "Lanai", "::", "LDBs_RI", ":", "case", "Lanai", "::", "LDBz_RI", ":", "case", "Lanai", "::", "STB_RI", ":", "Width", "=", "1", ";", "break", ";", "}", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "1", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "assert", "(", "BaseOp", "->", "isReg", "(", ")", "&&", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

[ "Lanai", "Lanai", "4", "1", "2", "3", "3", "Lanai::LDW_RI", "Lanai::LDW_RR", "Lanai::SW_RR", "Lanai::SW_RI", "4", "Lanai::LDHs_RI", "Lanai::LDHz_RI", "Lanai::STH_RI", "2", "Lanai::LDBs_RI", "Lanai::LDBz_RI", "Lanai::STB_RI", "1", "1", "2", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"" ]

[]

[ "<s>", "static", "bool", "mips_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict_p", ")", "{", "struct", "mips_address_info", "addr", ";", "return", "mips_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "strict_p", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "implement", "GO_IF_LEGITIMATE_ADDRESS", ".", "It", "returns", "a", "nonzero", "value", "if", "X", "is", "a", "legitimate", "address", "for", "a", "memory", "operand", "of", "the", "indicated", "MODE", ".", "STRICT", "is", "nonzero", "if", "this", "function", "is", "called", "during", "reload", "." ]

[ "mips" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "bool", "thumb_force_lr_save", "(", "void", ")", "{", "return", "!", "cfun", "->", "machine", "->", "lr_save_eliminated", "&&", "(", "!", "leaf_function_p", "(", ")", "||", "thumb_far_jump_used_p", "(", ")", "||", "regs_ever_live", "[", "LR_REGNUM", "]", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "needs", "to", "save/restore", "LR", "." ]

[ "arm" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SP", "::", "RETL", "&&", "\"Can only put epilog before 'retl' instruction!\"", ")", ";", "if", "(", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "RESTORErr", ")", ",", "SP", "::", "G0", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ";", "return", ";", "}", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SP", "::", "ADDrr", ",", "SP", "::", "ADDri", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::RETL", "\"Can only put epilog before 'retl' instruction!\"", "SP::RESTORErr", "SP::G0", "SP::G0", "SP::G0", "0", "SP", "SP::ADDrr", "SP::ADDri" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createARMELFObjectWriter", "(", "OS", ",", "OSABI", ",", "isLittle", "(", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "arm_test_fpu_data", "(", "void", ")", "{", "auto_sbitmap", "isa_all_fpubits_internal", "(", "isa_num_bits", ")", ";", "auto_sbitmap", "fpubits", "(", "isa_num_bits", ")", ";", "auto_sbitmap", "tmpset", "(", "isa_num_bits", ")", ";", "static", "const", "enum", "isa_feature", "fpu_bitlist_internal", "[", "]", "=", "{", "ISA_ALL_FPU_INTERNAL", ",", "isa_nobit", "}", ";", "arm_initialize_isa", "(", "isa_all_fpubits_internal", ",", "fpu_bitlist_internal", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "TARGET_FPU_auto", ";", "i", "++", ")", "{", "arm_initialize_isa", "(", "fpubits", ",", "all_fpus", "[", "i", "]", ".", "isa_bits", ")", ";", "bitmap_and_compl", "(", "tmpset", ",", "isa_all_fpubits_internal", ",", "fpubits", ")", ";", "bitmap_clear", "(", "isa_all_fpubits_internal", ")", ";", "bitmap_copy", "(", "isa_all_fpubits_internal", ",", "tmpset", ")", ";", "}", "if", "(", "!", "bitmap_empty_p", "(", "isa_all_fpubits_internal", ")", ")", "{", "fprintf", "(", "stderr", ",", "\"Error: found feature bits in the ALL_FPU_INTERAL\"", "\" group that are not defined by any FPU.\\n\"", "\" Check your arm-cpus.in.\\n\"", ")", ";", "ASSERT_TRUE", "(", "bitmap_empty_p", "(", "isa_all_fpubits_internal", ")", ")", ";", "}", "}", "</s>" ]

[ "Scan", "the", "static", "data", "tables", "generated", "by", "parsecpu.awk", "looking", "for", "potential", "issues", "with", "the", "data", ".", "Here", "we", "check", "for", "consistency", "between", "the", "fpu", "bits", ",", "in", "particular", "we", "check", "that", "ISA_ALL_FPU_INTERNAL", "does", "not", "contain", "a", "feature", "bit", "that", "is", "not", "defined", "by", "any", "FPU", "flag", "." ]

[ "arm", "0", "\"Error: found feature bits in the ALL_FPU_INTERAL\"", "\" group that are not defined by any FPU.\\n\"", "\" Check your arm-cpus.in.\\n\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", ">", "&", "Patterns", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "Aggressive", ")", "return", "false", ";", "if", "(", "!", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ")", "return", "false", ";", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "m68k_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "DATA_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "8", ")", "return", "true", ";", "}", "else", "if", "(", "ADDRESS_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "16", ")", "return", "true", ";", "}", "else", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "TARGET_FP_REG_SIZE", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Value", "is", "true", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", ".", "On", "the", "68000", ",", "we", "let", "the", "cpu", "registers", "can", "hold", "any", "mode", ",", "but", "restrict", "the", "68881", "registers", "to", "floating-point", "modes", "." ]

[ "m68k", "4", "8", "4", "16" ]

[]

[ "<s>", "bool", "SIPreAllocateWWMRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"SIPreAllocateWWMRegs: function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "Matrix", "=", "&", "getAnalysis", "<", "LiveRegMatrix", ">", "(", ")", ";", "VRM", "=", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ";", "RegClassInfo", ".", "runOnMachineFunction", "(", "MF", ")", ";", "bool", "RegsAssigned", "=", "false", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "RPOT", ")", "{", "bool", "InWWM", "=", "false", ";", "for", "(", "MachineInstr", "&", "MI", ":", "*", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_SET_INACTIVE_B32", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_SET_INACTIVE_B64", ")", "RegsAssigned", "|=", "processDef", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ENTER_STRICT_WWM", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ENTER_STRICT_WQM", ")", "{", "LLVM_DEBUG", "(", "printWWMInfo", "(", "MI", ")", ")", ";", "InWWM", "=", "true", ";", "continue", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "EXIT_STRICT_WWM", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "EXIT_STRICT_WQM", ")", "{", "LLVM_DEBUG", "(", "printWWMInfo", "(", "MI", ")", ")", ";", "InWWM", "=", "false", ";", "}", "if", "(", "!", "InWWM", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Processing \"", "<<", "MI", ")", ";", "for", "(", "MachineOperand", "&", "DefOpnd", ":", "MI", ".", "defs", "(", ")", ")", "{", "RegsAssigned", "|=", "processDef", "(", "DefOpnd", ")", ";", "}", "}", "}", "if", "(", "!", "RegsAssigned", ")", "return", "false", ";", "rewriteRegs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"SIPreAllocateWWMRegs: function \"", "\"\\n\"", "AMDGPU::V_SET_INACTIVE_B32", "AMDGPU::V_SET_INACTIVE_B64", "0", "AMDGPU::ENTER_STRICT_WWM", "AMDGPU::ENTER_STRICT_WQM", "AMDGPU::EXIT_STRICT_WWM", "AMDGPU::EXIT_STRICT_WQM", "\"Processing \"" ]

[]

[ "<s>", "SchedBoundary", "(", "unsigned", "ID", ",", "const", "Twine", "&", "Name", ")", ":", "DAG", "(", "0", ")", ",", "Available", "(", "ID", ",", "Name", "+", "\".A\"", ")", ",", "Pending", "(", "ID", "<<", "ConvergingVLIWScheduler", "::", "LogMaxQID", ",", "Name", "+", "\".P\"", ")", ",", "CheckPending", "(", "false", ")", ",", "HazardRec", "(", "0", ")", ",", "ResourceModel", "(", "0", ")", ",", "CurrCycle", "(", "0", ")", ",", "IssueCount", "(", "0", ")", ",", "MinReadyCycle", "(", "UINT_MAX", ")", ",", "MaxMinLatency", "(", "0", ")", "{", "}", "</s>" ]

[ "Pending", "queues", "extend", "the", "ready", "queues", "with", "the", "same", "ID", "and", "the", "PendingFlag", "set", "." ]

[ "Hexagon", "0", "\".A\"", "\".P\"", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "SDValue", "LC3TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "LC3", "LC3", "\"Unimplemented operand\"", "ISD::GlobalAddress" ]

[]

[ "<s>", "bool", "SPUTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "typedef", "llvm", "::", "FunctionPass", "*", "(", "*", "BuilderFunc", ")", "(", "const", "char", "*", ")", ";", "BuilderFunc", "schedulerCreator", "=", "(", "BuilderFunc", ")", "(", "intptr_t", ")", "sys", "::", "DynamicLibrary", "::", "SearchForAddressOfSymbol", "(", "\"createTCESchedulerPass\"", ")", ";", "if", "(", "schedulerCreator", "!=", "NULL", ")", "PM", ".", "add", "(", "schedulerCreator", "(", "\"cellspu\"", ")", ")", ";", "PM", ".", "add", "(", "createSPUNopFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "\"createTCESchedulerPass\"", "\"cellspu\"", "SPU" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "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", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "LowerADD", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::ADD" ]

[]

[ "<s>", "bool", "const_vec_all_same_in_range_p", "(", "rtx", "x", ",", "HOST_WIDE_INT", "minval", ",", "HOST_WIDE_INT", "maxval", ")", "{", "rtx", "elt", ";", "return", "(", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "&&", "CONST_INT_P", "(", "elt", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "elt", ")", ",", "minval", ",", "maxval", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "const_vector", "with", "all", "duplicate", "elements", ",", "which", "is", "in", "the", "range", "between", "MINVAL", "and", "MAXVAL", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "rs6000_set_handled_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "gpr_is_wrapped_separately", "[", "i", "]", "=", "true", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "64", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "fpr_is_wrapped_separately", "[", "i", "-", "32", "]", "=", "true", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "cfun", "->", "machine", "->", "lr_is_wrapped_separately", "=", "true", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "2", ")", ")", "cfun", "->", "machine", "->", "toc_is_wrapped_separately", "=", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS", "." ]

[ "rs6000", "32", "64", "32", "0", "2" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETSTACKTOP", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER" ]

[]

[ "<s>", "bool", "PPCFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Load", ":", "return", "SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "IndirectBr", ":", "return", "SelectIndirectBr", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "SelectIToFP", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "SelectIToFP", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "FPToSI", ":", "return", "SelectFPToI", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "SelectFPToI", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "Add", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "ADD", ")", ";", "case", "Instruction", "::", "Or", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "OR", ")", ";", "case", "Instruction", "::", "Sub", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "SUB", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "SelectIntExt", "(", "I", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "PowerPC", "PPC", "ISD::ADD", "ISD::OR", "ISD::SUB" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "ExtraCode", "||", "!", "ExtraCode", "[", "0", "]", ")", "{", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "XCore", "XCore", "0" ]

[]

[ "<s>", "static", "bool", "is_lfs_stfs_insn", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "PARALLEL", ")", "return", "false", ";", "if", "(", "XVECLEN", "(", "pattern", ",", "0", ")", "!=", "2", ")", "return", "false", ";", "rtx", "set", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "return", "false", ";", "rtx", "clobber", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "clobber", ")", "!=", "CLOBBER", ")", "return", "false", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "rtx", "scratch", "=", "SET_DEST", "(", "clobber", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "UNSPEC", ")", "return", "false", ";", "if", "(", "XINT", "(", "src", ",", "1", ")", "==", "UNSPEC_SI_FROM_SF", "&&", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "GET_MODE", "(", "dest", ")", "==", "SImode", "&&", "GET_CODE", "(", "scratch", ")", "==", "SCRATCH", "&&", "GET_MODE", "(", "scratch", ")", "==", "V4SFmode", ")", "return", "true", ";", "if", "(", "XINT", "(", "src", ",", "1", ")", "==", "UNSPEC_SF_FROM_SI", "&&", "GET_CODE", "(", "dest", ")", "==", "REG", "&&", "GET_MODE", "(", "dest", ")", "==", "SFmode", "&&", "GET_CODE", "(", "scratch", ")", "==", "SCRATCH", "&&", "GET_MODE", "(", "scratch", ")", "==", "DImode", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "to", "see", "if", "we", "'re", "potentially", "looking", "at", "lfs/stfs", ".", "-", "PARALLEL", "containing", "a", "SET", "and", "a", "CLOBBER", "-", "stfs", ":", "-", "SET", "is", "from", "UNSPEC_SI_FROM_SF", "to", "MEM", ":", "SI", "-", "CLOBBER", "is", "a", "V4SF", "-", "lfs", ":", "-", "SET", "is", "from", "UNSPEC_SF_FROM_SI", "to", "REG", ":", "SF", "-", "CLOBBER", "is", "a", "DI" ]

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

[]

[ "<s>", "BitVector", "TOYRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "TOY", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "TOY", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "TOY", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "TOY", "::", "TMP", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "TOY", "TOY", "TOY::ZERO", "TOY::SP", "TOY::LR", "TOY::TMP" ]

[]

[ "<s>", "const", "MipsFrameLowering", "*", "MipsFrameLowering", "::", "create", "(", "const", "MipsSubtarget", "&", "ST", ")", "{", "return", "llvm", "::", "createMipsSEFrameLowering", "(", "ST", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "bool", "Thumb1RegisterInfo", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "FFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "FFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "8", ")", "-", "1", ")", "*", "4", "/", "2", ")", "return", "false", ";", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "ARM", "1", "8", "1", "4", "2" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicable", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "R600", "::", "KILLGT", ")", "{", "return", "false", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "R600", "::", "CF_ALU", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "begin", "(", ")", "!=", "MachineBasicBlock", "::", "const_iterator", "(", "MI", ")", ")", "return", "false", ";", "return", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "==", "0", ";", "}", "else", "if", "(", "isVector", "(", "MI", ")", ")", "{", "return", "false", ";", "}", "else", "{", "return", "TargetInstrInfo", "::", "isPredicable", "(", "MI", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "AMDGPU", "R600", "R600::KILLGT", "R600::CF_ALU", "3", "0", "4", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "cris_static_rtx_alignment", "(", "machine_mode", "mode", ")", "{", "return", "MAX", "(", "cris_preferred_mininum_alignment", "(", ")", ",", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_STATIC_RTX_ALIGNMENT", "." ]

[ "cris" ]

[]

[ "<s>", "virtual", "bool", "isFMAFasterThanFMulAndFAdd", "(", "EVT", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "NVPTX" ]

[]

[ "<s>", "rtx", "alpha_gp_save_rtx", "(", ")", "{", "rtx", "r", "=", "get_hard_reg_initial_val", "(", "DImode", ",", "29", ")", ";", "if", "(", "GET_CODE", "(", "r", ")", "!=", "MEM", ")", "r", "=", "gen_mem_addressof", "(", "r", ",", "NULL_TREE", ")", ";", "return", "r", ";", "}", "</s>" ]

[ "Return", "or", "create", "a", "pseudo", "containing", "the", "gp", "value", "for", "the", "current", "function", ".", "Needed", "only", "if", "TARGET_LD_BUGGY_LDGP", "." ]

[ "alpha", "29" ]

[]

[ "<s>", "MVT", "getPointerMemTy", "(", "const", "DataLayout", "&", "DL", ",", "uint32_t", "AS", "=", "0", ")", "const", "override", "{", "if", "(", "AS", "==", "WasmAddressSpace", "::", "EXTERNREF", ")", "return", "MVT", "::", "externref", ";", "if", "(", "AS", "==", "WasmAddressSpace", "::", "FUNCREF", ")", "return", "MVT", "::", "funcref", ";", "return", "TargetLowering", "::", "getPointerMemTy", "(", "DL", ",", "AS", ")", ";", "}", "</s>" ]

[ "Return", "the", "in-memory", "pointer", "type", "for", "the", "given", "address", "space", ",", "defaults", "to", "the", "pointer", "type", "from", "the", "data", "layout", "." ]

[ "WebAssembly", "0", "WasmAddressSpace::EXTERNREF", "MVT::externref", "WasmAddressSpace::FUNCREF", "MVT::funcref" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "HexagonInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "return", "TargetInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "cris_expand_pic_call_address", "(", "rtx", "*", "opp", ",", "rtx", "*", "markerp", ")", "{", "rtx", "op", "=", "*", "opp", ";", "gcc_assert", "(", "flag_pic", "&&", "MEM_P", "(", "op", ")", ")", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "CONSTANT_P", "(", "op", ")", "&&", "!", "CONST_INT_P", "(", "op", ")", ")", "{", "enum", "cris_symbol_type", "t", "=", "cris_symbol_type_of", "(", "op", ")", ";", "CRIS_ASSERT", "(", "can_create_pseudo_p", "(", ")", ")", ";", "if", "(", "t", "==", "cris_rel_symbol", ")", "{", "if", "(", "TARGET_V32", ")", "{", "rtx", "sym", "=", "GET_CODE", "(", "op", ")", "!=", "CONST", "?", "op", ":", "get_related_value", "(", "op", ")", ";", "HOST_WIDE_INT", "offs", "=", "get_integer_term", "(", "op", ")", ";", "gcc_assert", "(", "offs", "==", "0", ")", ";", "op", "=", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "sym", ")", ",", "CRIS_UNSPEC_PCREL", ")", ")", ";", "}", "else", "op", "=", "force_reg", "(", "Pmode", ",", "op", ")", ";", "*", "markerp", "=", "const0_rtx", ";", "}", "else", "if", "(", "t", "==", "cris_got_symbol", ")", "{", "if", "(", "TARGET_AVOID_GOTPLT", ")", "{", "rtx", "tem", ",", "rm", ",", "ro", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "tem", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "op", ")", ",", "TARGET_V32", "?", "CRIS_UNSPEC_PLT_PCREL", ":", "CRIS_UNSPEC_PLT_GOTREL", ")", ";", "tem", "=", "gen_rtx_CONST", "(", "Pmode", ",", "tem", ")", ";", "if", "(", "TARGET_V32", ")", "op", "=", "tem", ";", "else", "{", "rm", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "rm", ",", "tem", ")", ";", "ro", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "rm", ",", "pic_offset_table_rtx", ",", "ro", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", "!=", "ro", ")", "internal_error", "(", "\"expand_binop failed in movsi got\"", ")", ";", "op", "=", "ro", ";", "}", "}", "else", "{", "rtx", "tem", ",", "mem", ",", "rm", ",", "ro", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "tem", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "op", ")", ",", "CRIS_UNSPEC_PLTGOTREAD", ")", ";", "rm", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "rm", ",", "gen_rtx_CONST", "(", "Pmode", ",", "tem", ")", ")", ";", "ro", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "rm", ",", "pic_offset_table_rtx", ",", "ro", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", "!=", "ro", ")", "internal_error", "(", "\"expand_binop failed in movsi got\"", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "ro", ")", ";", "set_mem_alias_set", "(", "mem", ",", "new_alias_set", "(", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "op", "=", "mem", ";", "}", "*", "markerp", "=", "pic_offset_table_rtx", ";", "}", "else", "fatal_insn", "(", "\"unidentifiable call op\"", ",", "op", ")", ";", "*", "opp", "=", "replace_equiv_address_nv", "(", "*", "opp", ",", "op", ")", ";", "}", "else", "*", "markerp", "=", "pic_offset_table_rtx", ";", "}", "</s>" ]

[ "Worker", "function", "for", "expanding", "the", "address", "for", "PIC", "function", "calls", "." ]

[ "cris", "0", "0", "1", "1", "1", "0", "\"expand_binop failed in movsi got\"", "1", "1", "0", "\"expand_binop failed in movsi got\"", "1", "\"unidentifiable call op\"" ]

[]

[ "<s>", "static", "rtx", "frame_emit_store", "(", "int", "regno", ",", "int", "regno_note", ",", "rtx", "addr", ",", "rtx", "cfa", ",", "int", "cfa_offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "addr", ")", ";", "rtx", "mov", "=", "gen_movdi", "(", "mem", ",", "reg", ")", ";", "rtx", "reg_note", "=", "gen_rtx_REG", "(", "DImode", ",", "regno_note", ")", ";", "rtx", "cfa_relative_addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "cfa", ",", "GEN_INT", "(", "cfa_offset", ")", ")", ";", "rtx", "cfa_relative_mem", "=", "gen_frame_mem", "(", "DImode", ",", "cfa_relative_addr", ")", ";", "rtx", "real", "=", "gen_rtx_SET", "(", "cfa_relative_mem", ",", "reg_note", ")", ";", "add_reg_note", "(", "mov", ",", "REG_CFA_OFFSET", ",", "real", ")", ";", "return", "emit_insn", "(", "mov", ")", ";", "}", "</s>" ]

[ "Emit", "a", "store", "in", "the", "stack", "frame", "to", "save", "REGNO", "at", "address", "ADDR", ",", "and", "emit", "the", "corresponding", "REG_CFA_OFFSET", "note", "described", "by", "CFA", "and", "CFA_OFFSET", ".", "Return", "the", "emitted", "insn", "." ]

[ "tilegx" ]

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "SP", "}", ";", "static", "const", "uint16_t", "ReservedCPU64Regs", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "SP_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "const_iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "isTargetNaCl", "(", ")", ")", "{", "static", "const", "uint16_t", "PnaclReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "T6", ",", "Mips", "::", "T7", ",", "Mips", "::", "T8", "}", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "PnaclReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "PnaclReservedCPURegs", "[", "I", "]", ")", ";", "}", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPU64Regs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPU64Regs", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "AFGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "FGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S0", ")", ";", "else", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "}", "}", "Reserved", ".", "set", "(", "Mips", "::", "HWR29", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "HWR29_64", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPCtrl", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA_64", ")", ";", "}", "if", "(", "Subtarget", ".", "useSmallSection", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Mips", "Mips", "Mips::ZERO", "Mips::K0", "Mips::K1", "Mips::SP", "Mips::ZERO_64", "Mips::K0_64", "Mips::K1_64", "Mips::SP_64", "0", "Mips::T6", "Mips::T7", "Mips::T8", "0", "0", "Mips", "Mips::AFGR64RegClass", "Mips::AFGR64RegClass", "Mips::FGR64RegClass", "Mips::FGR64RegClass", "Mips", "Mips::S0", "Mips::FP", "Mips::FP_64", "Mips::HWR29", "Mips::HWR29_64", "Mips::DSPCtrl", "Mips", "Mips::RA", "Mips::RA_64", "Mips::GP", "Mips::GP_64" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "case", "G_GEP", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]

[]

[ "<s>", "unsigned", "Cpu0RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "Cpu0", "::", "FP", ")", ":", "(", "Cpu0", "::", "SP", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Cpu0", "Cpu0", "Cpu0::FP", "Cpu0::SP" ]

[]

[ "<s>", "void", "ia64_expand_compare", "(", "rtx", "*", "expr", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "expr", ")", ";", "rtx", "cmp", ";", "if", "(", "GET_MODE", "(", "*", "op0", ")", "==", "BImode", ")", "{", "gcc_assert", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "*", "op1", "==", "const0_rtx", ")", ";", "cmp", "=", "*", "op0", ";", "}", "else", "if", "(", "TARGET_HPUX", "&&", "GET_MODE", "(", "*", "op0", ")", "==", "TFmode", ")", "{", "enum", "qfcmp_magic", "{", "QCMP_INV", "=", "1", ",", "QCMP_UNORD", "=", "2", ",", "QCMP_EQ", "=", "4", ",", "QCMP_LT", "=", "8", ",", "QCMP_GT", "=", "16", "}", ";", "int", "magic", ";", "enum", "rtx_code", "ncode", ";", "rtx", "ret", ";", "gcc_assert", "(", "cmptf_libfunc", "&&", "GET_MODE", "(", "*", "op1", ")", "==", "TFmode", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "magic", "=", "QCMP_EQ", ";", "ncode", "=", "NE", ";", "break", ";", "case", "NE", ":", "magic", "=", "QCMP_EQ", ";", "ncode", "=", "EQ", ";", "break", ";", "case", "UNORDERED", ":", "magic", "=", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "ORDERED", ":", "magic", "=", "QCMP_UNORD", ";", "ncode", "=", "EQ", ";", "break", ";", "case", "LT", ":", "magic", "=", "QCMP_LT", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "LE", ":", "magic", "=", "QCMP_LT", "|", "QCMP_EQ", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "GT", ":", "magic", "=", "QCMP_GT", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "GE", ":", "magic", "=", "QCMP_GT", "|", "QCMP_EQ", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNLT", ":", "magic", "=", "QCMP_LT", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNLE", ":", "magic", "=", "QCMP_LT", "|", "QCMP_EQ", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNGT", ":", "magic", "=", "QCMP_GT", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNGE", ":", "magic", "=", "QCMP_GT", "|", "QCMP_EQ", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "start_sequence", "(", ")", ";", "ret", "=", "emit_library_call_value", "(", "cmptf_libfunc", ",", "0", ",", "LCT_CONST", ",", "DImode", ",", "*", "op0", ",", "TFmode", ",", "*", "op1", ",", "TFmode", ",", "GEN_INT", "(", "magic", ")", ",", "DImode", ")", ";", "cmp", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cmp", ",", "gen_rtx_fmt_ee", "(", "ncode", ",", "BImode", ",", "ret", ",", "const0_rtx", ")", ")", ")", ";", "rtx_insn", "*", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "insns", ",", "cmp", ",", "cmp", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "*", "op0", ",", "*", "op1", ")", ")", ";", "code", "=", "NE", ";", "}", "else", "{", "cmp", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cmp", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "*", "op0", ",", "*", "op1", ")", ")", ")", ";", "code", "=", "NE", ";", "}", "*", "expr", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cmp", ",", "const0_rtx", ")", ";", "*", "op0", "=", "cmp", ";", "*", "op1", "=", "const0_rtx", ";", "}", "</s>" ]

[ "Emit", "comparison", "instruction", "if", "necessary", ",", "returning", "the", "expression", "that", "holds", "the", "compare", "result", "in", "the", "proper", "mode", "." ]

[ "ia64", "1", "2", "4", "8", "16", "0" ]

[]

[ "<s>", "int", "SIFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "SIRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AMDGPU", "SI", "SI", "SI" ]

[]

[ "<s>", "static", "tree", "nvptx_get_worker_red_addr", "(", "tree", "type", ",", "tree", "offset", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "tree", "fndecl", "=", "nvptx_builtin_decl", "(", "NVPTX_BUILTIN_WORKER_ADDR", ",", "true", ")", ";", "tree", "size", "=", "build_int_cst", "(", "unsigned_type_node", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "tree", "align", "=", "build_int_cst", "(", "unsigned_type_node", ",", "GET_MODE_ALIGNMENT", "(", "mode", ")", "/", "BITS_PER_UNIT", ")", ";", "tree", "call", "=", "build_call_expr", "(", "fndecl", ",", "3", ",", "offset", ",", "size", ",", "align", ")", ";", "return", "fold_convert", "(", "build_pointer_type", "(", "type", ")", ",", "call", ")", ";", "}", "</s>" ]

[ "Generate", "a", "PTX", "builtin", "function", "call", "that", "returns", "the", "address", "in", "the", "worker", "reduction", "buffer", "at", "OFFSET", ".", "TYPE", "is", "the", "type", "of", "the", "data", "at", "that", "location", "." ]

[ "nvptx", "3" ]

[]

[ "<s>", "static", "rtx", "mcore_function_arg", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "arg_reg", ";", "if", "(", "!", "arg", ".", "named", "||", "arg", ".", "end_marker_p", "(", ")", ")", "return", "0", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "0", ";", "arg_reg", "=", "ROUND_REG", "(", "*", "get_cumulative_args", "(", "cum", ")", ",", "arg", ".", "mode", ")", ";", "if", "(", "arg_reg", "<", "NPARM_REGS", ")", "return", "handle_structs_in_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ",", "FIRST_PARM_REG", "+", "arg_reg", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "MCore", "the", "first", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", ".", "Any", "arg", "that", "starts", "within", "the", "first", "NPARM_REGS", "words", "is", "at", "least", "partially", "passed", "in", "a", "register", "unless", "its", "data", "type", "forbids", "." ]

[ "mcore", "0", "0", "0" ]

[]

[ "<s>", "bool", "Mips16DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "return", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "enum", "reg_class", "rs6000_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "in", ")", "{", "int", "regno", ";", "if", "(", "TARGET_ELF", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "MACHOPIC_INDIRECT", ")", ")", "{", "if", "(", "rclass", "!=", "BASE_REGS", "&&", "(", "GET_CODE", "(", "in", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "in", ")", "==", "HIGH", "||", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "in", ")", "==", "CONST", ")", ")", "return", "BASE_REGS", ";", "}", "if", "(", "GET_CODE", "(", "in", ")", "==", "REG", ")", "{", "regno", "=", "REGNO", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "1", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "in", ")", "==", "SUBREG", ")", "{", "regno", "=", "true_regnum", "(", "in", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "-", "1", ";", "}", "else", "regno", "=", "-", "1", ";", "if", "(", "TARGET_VSX", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "16", "&&", "!", "mode_supports_vmx_dform", "(", "mode", ")", "&&", "(", "(", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", "&&", "(", "regno", ">=", "0", "&&", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", ")", "||", "(", "(", "rclass", "==", "VSX_REGS", "||", "rclass", "==", "ALTIVEC_REGS", ")", "&&", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", ")", ")", "return", "FLOAT_REGS", ";", "if", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", "||", "(", "regno", ">=", "0", "&&", "INT_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "VSX_REGS", "&&", "(", "regno", "==", "-", "1", "||", "VSX_REGNO_P", "(", "regno", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "FP_REGNO_P", "(", "regno", ")", ")", "&&", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "NON_SPECIAL_REGS", ")", ")", "return", "(", "mode", "!=", "SDmode", "||", "lra_in_progress", ")", "?", "NO_REGS", ":", "GENERAL_REGS", ";", "if", "(", "(", "regno", "==", "-", "1", "||", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "&&", "rclass", "==", "ALTIVEC_REGS", ")", "return", "NO_REGS", ";", "if", "(", "(", "rclass", "==", "CR_REGS", "||", "rclass", "==", "CR0_REGS", ")", "&&", "regno", ">=", "0", "&&", "CR_REGNO_P", "(", "regno", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "of", "a", "scratch", "register", "needed", "to", "copy", "IN", "into", "or", "out", "of", "a", "register", "in", "RCLASS", "in", "MODE", ".", "If", "it", "can", "be", "done", "directly", ",", "NO_REGS", "is", "returned", "." ]

[ "powerpcspe", "1", "1", "1", "16", "0", "0", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "int", "h8300_regs_ok_for_stm", "(", "int", "n", ",", "rtx", "operands", "[", "]", ")", "{", "switch", "(", "n", ")", "{", "case", "2", ":", "return", "(", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "0", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "1", ")", "||", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "2", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "3", ")", "||", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "4", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "5", ")", ")", ";", "case", "3", ":", "return", "(", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "0", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "1", "&&", "REGNO", "(", "operands", "[", "2", "]", ")", "==", "2", ")", "||", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "4", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "5", "&&", "REGNO", "(", "operands", "[", "2", "]", ")", "==", "6", ")", ")", ";", "case", "4", ":", "return", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "0", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "1", "&&", "REGNO", "(", "operands", "[", "2", "]", ")", "==", "2", "&&", "REGNO", "(", "operands", "[", "3", "]", ")", "==", "3", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "nonzero", "if", "OPERANDS", "are", "valid", "for", "stm", "(", "or", "ldm", ")", "that", "pushes", "(", "or", "pops", ")", "N", "registers", ".", "OPERANDS", "are", "assumed", "to", "be", "an", "array", "of", "registers", "." ]

[ "h8300", "2", "0", "0", "1", "1", "0", "2", "1", "3", "0", "4", "1", "5", "3", "0", "0", "1", "1", "2", "2", "0", "4", "1", "5", "2", "6", "4", "0", "0", "1", "1", "2", "2", "3", "3" ]

[]

[ "<s>", "void", "arm_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "scratch", ";", "machine_mode", "mode", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "bool", "is_weak", ";", "rtx_code_label", "*", "label1", ",", "*", "label2", ";", "rtx", "x", ",", "cond", ";", "rval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "oldval", "=", "operands", "[", "2", "]", ";", "newval", "=", "operands", "[", "3", "]", ";", "is_weak", "=", "(", "operands", "[", "4", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "5", "]", ")", ";", "mod_f", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "6", "]", ")", ";", "scratch", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "bool", "use_acquire", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "mod_s", "==", "MEMMODEL_RELAXED", "||", "mod_s", "==", "MEMMODEL_CONSUME", "||", "mod_s", "==", "MEMMODEL_RELEASE", ")", ";", "bool", "use_release", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "mod_s", "==", "MEMMODEL_RELAXED", "||", "mod_s", "==", "MEMMODEL_CONSUME", "||", "mod_s", "==", "MEMMODEL_ACQUIRE", ")", ";", "if", "(", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "arm_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "use_acquire", ")", ";", "cond", "=", "arm_gen_compare_reg", "(", "NE", ",", "rval", ",", "oldval", ",", "scratch", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ")", ";", "arm_emit_store_exclusive", "(", "mode", ",", "scratch", ",", "mem", ",", "newval", ",", "use_release", ")", ";", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "scratch", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cond", ",", "x", ")", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ")", ";", "}", "if", "(", "mod_f", "!=", "MEMMODEL_RELAXED", ")", "emit_label", "(", "label2", ")", ";", "if", "(", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "mod_f", "==", "MEMMODEL_RELAXED", ")", "emit_label", "(", "label2", ")", ";", "}", "</s>" ]

[ "Split", "a", "compare", "and", "swap", "pattern", ".", "It", "is", "IMPLEMENTATION", "DEFINED", "whether", "another", "memory", "store", "between", "the", "load-exclusive", "and", "store-exclusive", "can", "reset", "the", "monitor", "from", "Exclusive", "to", "Open", "state", ".", "This", "means", "we", "must", "wait", "until", "after", "reload", "to", "split", "the", "pattern", ",", "lest", "we", "get", "a", "register", "spill", "in", "the", "middle", "of", "the", "atomic", "sequence", "." ]

[ "arm", "0", "1", "2", "3", "4", "5", "6", "7" ]

[]

[ "<s>", "unsigned", "ValueEnumerator", "::", "getGlobalBasicBlockID", "(", "const", "BasicBlock", "*", "BB", ")", "const", "{", "unsigned", "&", "Idx", "=", "GlobalBasicBlockIDs", "[", "BB", "]", ";", "if", "(", "Idx", "!=", "0", ")", "return", "Idx", "-", "1", ";", "IncorporateFunctionInfoGlobalBBIDs", "(", "BB", "->", "getParent", "(", ")", ",", "GlobalBasicBlockIDs", ")", ";", "return", "getGlobalBasicBlockID", "(", "BB", ")", ";", "}", "</s>" ]

[ "getGlobalBasicBlockID", "-", "This", "returns", "the", "function-specific", "ID", "for", "the", "specified", "basic", "block", "." ]

[ "DirectX", "0", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SICRegisterInfo", "::", "intRegClass", "(", "unsigned", "Size", ")", "const", "{", "return", "&", "SIC", "::", "CPURegsRegClass", ";", "}", "</s>" ]

[ "Return", "GPR", "register", "class", "." ]

[ "SIC", "SIC", "SIC::CPURegsRegClass" ]

[]

[ "<s>", "AMDGPUSubtarget", "&", "AMDGPUSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+fp64-denormals,\"", ")", ";", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "if", "(", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "FP32Denormals", "=", "false", ";", "FP64Denormals", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "R600", "256", "\"+promote-alloca,+fp64-denormals,\"" ]

[]

[ "<s>", "void", "J2AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "auto", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "J2", "::", "fixup_J2_PC2_12", ":", "applyDisplacement", "<", "12", ",", "2", ">", "(", "Value", ",", "Data", ".", "slice", "(", "Offset", ")", ")", ";", "break", ";", "case", "J2", "::", "fixup_J2_PC2_8", ":", "applyDisplacement", "<", "8", ",", "2", ">", "(", "Value", ",", "Data", ".", "slice", "(", "Offset", ")", ")", ";", "break", ";", "case", "J2", "::", "fixup_J2_PC4_8", ":", "{", "applyDisplacement", "<", "8", ",", "4", ">", "(", "Value", ",", "Data", ".", "slice", "(", "Offset", ")", ")", ";", "break", ";", "}", "case", "FK_Data_4", ":", "*", "reinterpret_cast", "<", "uint32_t", "*", ">", "(", "Data", ".", "slice", "(", "Offset", ")", ".", "data", "(", ")", ")", "=", "Value", "/", "4", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unkown fixup!\"", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "J2", "J2", "J2::fixup_J2_PC2_12", "12", "2", "J2::fixup_J2_PC2_8", "8", "2", "J2::fixup_J2_PC4_8", "8", "4", "4", "\"Unkown fixup!\"" ]

[]

[ "<s>", "static", "unsigned", "estimateStackSize", "(", "MachineFunction", "&", "MF", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "int", "Offset", "=", "0", ";", "for", "(", "int", "i", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "i", "!=", "0", ";", "++", "i", ")", "{", "int", "FixedOff", "=", "-", "MFI", "->", "getObjectOffset", "(", "i", ")", ";", "if", "(", "FixedOff", ">", "Offset", ")", "Offset", "=", "FixedOff", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "MFI", "->", "isDeadObjectIndex", "(", "i", ")", ")", "continue", ";", "Offset", "+=", "MFI", "->", "getObjectSize", "(", "i", ")", ";", "unsigned", "Align", "=", "MFI", "->", "getObjectAlignment", "(", "i", ")", ";", "Offset", "=", "(", "Offset", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MaxAlign", "=", "std", "::", "max", "(", "Align", ",", "MaxAlign", ")", ";", "}", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "&&", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "Offset", "+=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "StackAlign", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "&&", "MFI", "->", "getObjectIndexEnd", "(", ")", "!=", "0", ")", ")", "StackAlign", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "else", "StackAlign", "=", "TFI", "->", "getTransientStackAlignment", "(", ")", ";", "StackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MaxAlign", ")", ";", "unsigned", "AlignMask", "=", "StackAlign", "-", "1", ";", "Offset", "=", "(", "Offset", "+", "AlignMask", ")", "&", "~", "uint64_t", "(", "AlignMask", ")", ";", "return", "(", "unsigned", ")", "Offset", ";", "}", "</s>" ]

[ "Estimate", "and", "return", "the", "size", "of", "the", "stack", "frame", "." ]

[ "AArch64", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "SystemZRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the frame register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "SystemZ", "SystemZ", "0", "\"What is the frame register\"", "0" ]

[]

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

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "AArch64" ]

[]

[ "<s>", "static", "opt_machine_mode", "ix86_get_mask_mode", "(", "poly_uint64", "nunits", ",", "poly_uint64", "vector_size", ")", "{", "unsigned", "elem_size", "=", "vector_size", "/", "nunits", ";", "if", "(", "(", "TARGET_AVX512F", "&&", "vector_size", "==", "64", ")", "||", "(", "TARGET_AVX512VL", "&&", "(", "vector_size", "==", "32", "||", "vector_size", "==", "16", ")", ")", ")", "{", "if", "(", "elem_size", "==", "4", "||", "elem_size", "==", "8", "||", "TARGET_AVX512BW", ")", "return", "smallest_int_mode_for_size", "(", "nunits", ")", ";", "}", "scalar_int_mode", "elem_mode", "=", "smallest_int_mode_for_size", "(", "elem_size", "*", "BITS_PER_UNIT", ")", ";", "gcc_assert", "(", "elem_size", "*", "nunits", "==", "vector_size", ")", ";", "return", "mode_for_vector", "(", "elem_mode", ",", "nunits", ")", ";", "}", "</s>" ]

[ "Implemenation", "of", "targetm.vectorize.get_mask_mode", "." ]

[ "i386", "64", "32", "16", "4", "8" ]

[]

[ "<s>", "int", "arc_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "len", ",", "bool", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "len", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "return", "len", ";", "if", "(", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_doloop_end_i", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_insn", "(", "insn", ")", ";", "return", "(", "(", "LABEL_P", "(", "prev", ")", "||", "(", "TARGET_ARC600", "&&", "(", "JUMP_P", "(", "prev", ")", "||", "CALL_P", "(", "prev", ")", "||", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", ")", ")", ")", "?", "len", "+", "4", ":", "len", ")", ";", "}", "if", "(", "TARGET_PAD_RETURN", "&&", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_RETURN", ")", "{", "rtx_insn", "*", "prev", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "!", "prev", "||", "!", "(", "prev", "=", "prev_active_insn", "(", "prev", ")", ")", "||", "(", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "?", "CALL_ATTR", "(", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", "->", "insn", "(", "0", ")", ",", "NON_SIBCALL", ")", ":", "CALL_ATTR", "(", "prev", ",", "NON_SIBCALL", ")", ")", ")", "return", "len", "+", "4", ";", "}", "if", "(", "TARGET_ARC600", ")", "{", "rtx_insn", "*", "succ", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "succ", "&&", "INSN_P", "(", "succ", ")", ")", "len", "+=", "arc600_corereg_hazard", "(", "insn", ",", "succ", ")", ";", "}", "extract_constrain_insn_cached", "(", "insn", ")", ";", "return", "len", ";", "}", "</s>" ]

[ "Return", "length", "adjustment", "for", "INSN", "." ]

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveVariables", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveVariables", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "alias", "(", "RegisterRef", "RA", ",", "RegisterRef", "RB", ")", "const", "{", "if", "(", "!", "isRegMaskId", "(", "RA", ".", "Reg", ")", ")", "return", "!", "isRegMaskId", "(", "RB", ".", "Reg", ")", "?", "aliasRR", "(", "RA", ",", "RB", ")", ":", "aliasRM", "(", "RA", ",", "RB", ")", ";", "return", "!", "isRegMaskId", "(", "RB", ".", "Reg", ")", "?", "aliasRM", "(", "RB", ",", "RA", ")", ":", "aliasMM", "(", "RA", ",", "RB", ")", ";", "}", "</s>" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "TPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_AllRegs_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "enum", "epiphany_function_type", "epiphany_compute_function_type", "(", "tree", "decl", ")", "{", "tree", "a", ";", "static", "enum", "epiphany_function_type", "fn_type", "=", "EPIPHANY_FUNCTION_UNKNOWN", ";", "static", "tree", "last_fn", "=", "NULL_TREE", ";", "if", "(", "decl", "==", "NULL_TREE", ")", "{", "fn_type", "=", "EPIPHANY_FUNCTION_UNKNOWN", ";", "last_fn", "=", "NULL_TREE", ";", "return", "fn_type", ";", "}", "if", "(", "decl", "==", "last_fn", "&&", "fn_type", "!=", "EPIPHANY_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "EPIPHANY_FUNCTION_NORMAL", ";", "for", "(", "a", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "a", ";", "a", "=", "TREE_CHAIN", "(", "a", ")", ")", "{", "tree", "name", "=", "TREE_PURPOSE", "(", "a", ")", ";", "if", "(", "name", "==", "get_identifier", "(", "\"interrupt\"", ")", ")", "fn_type", "=", "EPIPHANY_FUNCTION_INTERRUPT", ";", "}", "last_fn", "=", "decl", ";", "return", "fn_type", ";", "}", "</s>" ]

[ "Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "." ]

[ "epiphany", "\"interrupt\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU16RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "case", "'l'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO", ",", "&", "Mips", "::", "LORegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO64", ",", "&", "Mips", "::", "LORegs64RegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "0", "MVT::i32", "MVT::i16", "MVT::i8", "Mips", "0U", "Mips::CPU16RegsRegClass", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPU64RegsRegClass", "0u", "0", "MVT::f32", "0U", "Mips::FGR32RegClass", "MVT::f64", "0U", "Mips::FGR64RegClass", "0U", "Mips::AFGR64RegClass", "MVT::i32", "Mips::T9", "Mips::CPURegsRegClass", "MVT::i64", "\"Unexpected type.\"", "Mips::T9_64", "Mips::CPU64RegsRegClass", "MVT::i32", "Mips::LO", "Mips::LORegsRegClass", "Mips::LO64", "Mips::LORegs64RegClass", "0u", "0" ]

[]

[ "<s>", "static", "void", "arc_reorg_loops", "(", "void", ")", "{", "reorg_loops", "(", "true", ",", "&", "arc_doloop_hooks", ")", ";", "}", "</s>" ]

[ "Run", "from", "machine_dependent_reorg", ",", "this", "pass", "looks", "for", "doloop_end", "insns", "and", "tries", "to", "rewrite", "the", "RTL", "of", "these", "loops", "so", "that", "proper", "Blackfin", "hardware", "loops", "are", "generated", "." ]

[ "arc" ]

[]

[ "<s>", "static", "reg_class_t", "bfin_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "default_class", "=", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "?", "DPREGS", ":", "DREGS", ";", "enum", "reg_class", "x_class", "=", "NO_REGS", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "code", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ",", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "==", "-", "1", ")", "code", "=", "MEM", ";", "else", "x_class", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "}", "if", "(", "fp_plus_const_operand", "(", "x", ",", "mode", ")", ")", "{", "rtx", "op2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "int", "large_constant_p", "=", "!", "satisfies_constraint_Ks7", "(", "op2", ")", ";", "if", "(", "rclass", "==", "PREGS", "||", "rclass", "==", "PREGS_CLOBBERED", ")", "return", "NO_REGS", ";", "if", "(", "(", "rclass", "==", "DREGS", "||", "rclass", "==", "DPREGS", ")", "&&", "!", "large_constant_p", ")", "return", "NO_REGS", ";", "sri", "->", "icode", "=", "CODE_FOR_reload_insi", ";", "return", "NO_REGS", ";", "}", "if", "(", "x_class", "==", "AREGS", "||", "x_class", "==", "EVEN_AREGS", "||", "x_class", "==", "ODD_AREGS", ")", "return", "(", "rclass", "==", "DREGS", "||", "rclass", "==", "AREGS", "||", "rclass", "==", "EVEN_AREGS", "||", "rclass", "==", "ODD_AREGS", "?", "NO_REGS", ":", "DREGS", ")", ";", "if", "(", "rclass", "==", "AREGS", "||", "rclass", "==", "EVEN_AREGS", "||", "rclass", "==", "ODD_AREGS", ")", "{", "if", "(", "code", "==", "MEM", ")", "{", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_inpdi", ":", "CODE_FOR_reload_outpdi", ";", "return", "NO_REGS", ";", "}", "if", "(", "x", "!=", "const0_rtx", "&&", "x_class", "!=", "DREGS", ")", "{", "return", "DREGS", ";", "}", "else", "return", "NO_REGS", ";", "}", "if", "(", "rclass", "==", "CCREGS", "&&", "x_class", "!=", "DREGS", ")", "return", "DREGS", ";", "if", "(", "x_class", "==", "CCREGS", "&&", "rclass", "!=", "DREGS", ")", "return", "DREGS", ";", "if", "(", "code", "==", "MEM", ")", "if", "(", "!", "reg_class_subset_p", "(", "rclass", ",", "default_class", ")", ")", "return", "default_class", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Inform", "reload", "about", "cases", "where", "moving", "X", "with", "a", "mode", "MODE", "to", "a", "register", "in", "RCLASS", "requires", "an", "extra", "scratch", "register", ".", "Return", "the", "class", "needed", "for", "the", "scratch", "register", "." ]

[ "bfin", "4", "1", "1" ]

[]

[ "<s>", "static", "void", "mips_print_float_branch_condition", "(", "FILE", "*", "file", ",", "enum", "rtx_code", "code", ",", "int", "letter", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "if", "(", "ISA_HAS_CCF", ")", "fputs", "(", "\"c1eqz\"", ",", "file", ")", ";", "else", "fputs", "(", "\"c1f\"", ",", "file", ")", ";", "break", ";", "case", "NE", ":", "if", "(", "ISA_HAS_CCF", ")", "fputs", "(", "\"c1nez\"", ",", "file", ")", ";", "else", "fputs", "(", "\"c1t\"", ",", "file", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"'%%%c' is not a valid operand prefix\"", ",", "letter", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Likewise", "floating-point", "branches", "." ]

[ "mips", "\"c1eqz\"", "\"c1f\"", "\"c1nez\"", "\"c1t\"", "\"'%%%c' is not a valid operand prefix\"" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "||", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "unsigned", "AS", "=", "DstPtrInfo", ".", "getAddrSpace", "(", ")", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "AS", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "SDValue", "TPCTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Custom combining: skipping\\n\"", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "return", "performBitCastCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "performShuffleCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "\"Custom combining: skipping\\n\"", "ISD::BITCAST", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "void", "AnalyzeCallResult", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "CCAssignFn", "Fn", ",", "const", "Type", "*", "RetTy", ",", "const", "char", "*", "Func", ")", "{", "PreAnalyzeCallResultForF128", "(", "Ins", ",", "RetTy", ",", "Func", ")", ";", "PreAnalyzeCallResultForVectorFloat", "(", "Ins", ",", "RetTy", ")", ";", "CCState", "::", "AnalyzeCallResult", "(", "Ins", ",", "Fn", ")", ";", "OriginalArgWasFloat", ".", "clear", "(", ")", ";", "OriginalArgWasF128", ".", "clear", "(", ")", ";", "OriginalArgWasFloatVector", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AnalyzeCallResult", "-", "Same", "as", "above", "except", "it", "'s", "specialized", "for", "calls", "which", "produce", "a", "single", "value", "." ]

[ "Mips", "ISD::InputArg" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Collect LOH **********\\n\"", "<<", "\"Looking in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "0", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "0", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "make_range", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "LDRXui", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "\"Expected reg def\"", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "\"Expected reg use\"", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "0", "&&", "OpIdx", ">=", "0", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "AArch64", "::", "ADRP", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "0", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Collect LOH **********\\n\"", "\"Looking in function \"", "AArch64", "AArch64", "0", "0", "AArch64::ADDXri", "AArch64::LDRXui", "0", "1", "\"Expected reg def\"", "\"Expected reg use\"", "0", "0", "AArch64::ADRP", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPULowerKernelAttributes", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "int", "arm_apply_result_size", "(", "void", ")", "{", "int", "size", "=", "16", ";", "if", "(", "TARGET_32BIT", ")", "{", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "size", "+=", "32", ";", "if", "(", "TARGET_IWMMXT_ABI", ")", "size", "+=", "8", ";", "}", "return", "size", ";", "}", "</s>" ]

[ "Determine", "the", "amount", "of", "memory", "needed", "to", "store", "the", "possible", "return", "registers", "of", "an", "untyped", "call", "." ]

[ "arm", "16", "32", "8" ]

[]

[ "<s>", "const", "M88kSubtarget", "*", "M88kTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "M88kSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k", "\"target-cpu\"", "\"target-features\"", "M88k" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "Kind", "==", "K_Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Nyuzi", "\"Invalid type access!\"" ]

[]

[ "<s>", "static", "rtx", "frv_frame_mem", "(", "enum", "machine_mode", "mode", ",", "rtx", "base", ",", "int", "offset", ")", "{", "return", "gen_rtx_MEM", "(", "mode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "frv_frame_offset_rtx", "(", "offset", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "(", "mem", ":", "MODE", "(", "plus", ":", "Pmode", "BASE", "(", "frv_frame_offset", "OFFSET", ")", ")", ")", ")", ".", "The", "prologue", "and", "epilogue", "uses", "such", "expressions", "to", "access", "the", "stack", "." ]

[ "frv" ]

[]

[ "<s>", "const", "char", "*", "avr_devicespecs_file", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "mmcu", "=", "NULL", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"Running spec function '%s' with %d args\\n\\n\"", ",", "__FUNCTION__", ",", "argc", ")", ";", "switch", "(", "argc", ")", "{", "case", "0", ":", "fatal_error", "(", "input_location", ",", "\"bad usage of spec function %qs\"", ",", "\"device-specs-file\"", ")", ";", "return", "X_NODEVLIB", ";", "case", "1", ":", "if", "(", "strcmp", "(", "\"device-specs\"", ",", "argv", "[", "0", "]", ")", "==", "0", ")", "{", "return", "X_NODEVLIB", ";", "}", "mmcu", "=", "AVR_MMCU_DEFAULT", ";", "break", ";", "default", ":", "mmcu", "=", "argv", "[", "1", "]", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "strcmp", "(", "mmcu", ",", "argv", "[", "i", "]", ")", "!=", "0", ")", "{", "error", "(", "\"specified option %qs more than once\"", ",", "\"-mmcu\"", ")", ";", "return", "X_NODEVLIB", ";", "}", "break", ";", "}", "for", "(", "const", "char", "*", "s", "=", "mmcu", ";", "*", "s", ";", "s", "++", ")", "if", "(", "!", "ISALNUM", "(", "*", "s", ")", "&&", "'-'", "!=", "*", "s", "&&", "'_'", "!=", "*", "s", ")", "{", "error", "(", "\"strange device name %qs after %qs: bad character %qc\"", ",", "mmcu", ",", "\"-mmcu=\"", ",", "*", "s", ")", ";", "return", "X_NODEVLIB", ";", "}", "return", "concat", "(", "\"-specs=device-specs\"", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "\"%s\"", "\" %{mmcu=avr*:\"", "X_NODEVLIB", "\"} %{!mmcu=*:\"", "X_NODEVLIB", "\"}\"", ",", "\" \"", "X_NODEVLIB", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Implement", "spec", "function", "`", "device-specs-file麓", ".", "Compose", "-specs=", "<", "specs-file-name", ">", "%", "s", ".", "If", "everything", "went", "well", "then", "argv", "[", "0", "]", "is", "the", "inflated", "(", "absolute", ")", "specs", "directory", "and", "argv", "[", "1", "]", "is", "a", "device", "or", "core", "name", "as", "supplied", "by", "-mmcu=", "*", ".", "When", "building", "GCC", "the", "path", "might", "be", "relative", "." ]

[ "avr", "\"Running spec function '%s' with %d args\\n\\n\"", "0", "\"bad usage of spec function %qs\"", "\"device-specs-file\"", "1", "\"device-specs\"", "0", "0", "1", "2", "0", "\"specified option %qs more than once\"", "\"-mmcu\"", "\"strange device name %qs after %qs: bad character %qc\"", "\"-mmcu=\"", "\"-specs=device-specs\"", "\"specs-\"", "\"%s\"", "\" %{mmcu=avr*:\"", "\"} %{!mmcu=*:\"", "\"}\"", "\" \"" ]

[]

[ "<s>", "ARM64TargetLowering", "::", "ConstraintType", "ARM64TargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'z'", ":", "return", "C_Other", ";", "case", "'x'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "B", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "B", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setIfReturnsVoid", "(", "!", "Val", ")", ";", "assert", "(", "!", "Val", "==", "VRegs", ".", "empty", "(", ")", "&&", "\"Return value without a vreg\"", ")", ";", "CallingConv", "::", "ID", "CC", "=", "B", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "bool", "IsShader", "=", "AMDGPU", "::", "isShader", "(", "CC", ")", ";", "const", "bool", "IsWaveEnd", "=", "(", "IsShader", "&&", "MFI", "->", "returnsVoid", "(", ")", ")", "||", "AMDGPU", "::", "isKernel", "(", "CC", ")", ";", "if", "(", "IsWaveEnd", ")", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "auto", "const", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "ReturnOpc", "=", "IsShader", "?", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ":", "AMDGPU", "::", "S_SETPC_B64_return", ";", "auto", "Ret", "=", "B", ".", "buildInstrNoInsert", "(", "ReturnOpc", ")", ";", "Register", "ReturnAddrVReg", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "ReturnAddrVReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "CCR_SGPR_64RegClass", ")", ";", "Ret", ".", "addUse", "(", "ReturnAddrVReg", ")", ";", "}", "if", "(", "!", "lowerReturnVal", "(", "B", ",", "Val", ",", "VRegs", ",", "Ret", ")", ")", "return", "false", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "Register", "LiveInReturn", "=", "MF", ".", "addLiveIn", "(", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "B", ".", "buildCopy", "(", "ReturnAddrVReg", ",", "LiveInReturn", ")", ";", "}", "B", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "\"Return value without a vreg\"", "AMDGPU::isShader", "AMDGPU::isKernel", "AMDGPU::S_ENDPGM", "0", "AMDGPU::SI_RETURN_TO_EPILOG", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64_return", "AMDGPU::CCR_SGPR_64RegClass", "AMDGPU::S_SETPC_B64_return", "SI", "AMDGPU::SGPR_64RegClass" ]

[]

[ "<s>", "yaml", "::", "MachineFunctionInfo", "*", "RISCVTargetMachine", "::", "createDefaultFuncInfoYAML", "(", ")", "const", "{", "return", "new", "yaml", "::", "RISCVMachineFunctionInfo", "(", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "default", "initialized", "instance", "of", "the", "YAML", "representation", "for", "the", "MachineFunctionInfo", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "rtx", "avr_builtin_setjmp_frame_value", "(", "void", ")", "{", "rtx", "xval", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_subhi3", "(", "xval", ",", "virtual_stack_vars_rtx", ",", "gen_int_mode", "(", "STARTING_FRAME_OFFSET", ",", "Pmode", ")", ")", ")", ";", "return", "xval", ";", "}", "</s>" ]

[ "Actual", "start", "of", "frame", "is", "virtual_stack_vars_rtx", "this", "is", "offset", "from", "frame", "pointer", "by", "+TARGET_STARTING_FRAME_OFFSET", ".", "Using", "saved", "frame", "=", "virtual_stack_vars_rtx", "-", "TARGET_STARTING_FRAME_OFFSET", "avoids", "creating", "add/sub", "of", "offset", "in", "nonlocal", "goto", "and", "setjmp", "." ]

[ "avr" ]

[]

[ "<s>", "static", "inline", "bool", "cris_index_p", "(", "const_rtx", "x", ",", "bool", "strict", ")", "{", "return", "(", "REG_P", "(", "x", ")", "&&", "reg_ok_for_index_p", "(", "x", ",", "strict", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "X", "is", "a", "valid", "index", "register", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "findCommutedOpIndices", "(", "MCInstrDesc", "Desc", ",", "unsigned", "&", "SrcOpIdx0", ",", "unsigned", "&", "SrcOpIdx1", ")", "const", "{", "if", "(", "!", "Desc", ".", "isCommutable", "(", ")", ")", "return", "false", ";", "unsigned", "Opc", "=", "Desc", ".", "getOpcode", "(", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "false", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "false", ";", "return", "fixCommutedOpIndices", "(", "SrcOpIdx0", ",", "SrcOpIdx1", ",", "Src0Idx", ",", "Src1Idx", ")", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "char", "*", "rx_gen_move_template", "(", "rtx", "*", "operands", ",", "bool", "is_movu", ")", "{", "static", "char", "out_template", "[", "64", "]", ";", "const", "char", "*", "extension", "=", "TARGET_AS100_SYNTAX", "?", "\".L\"", ":", "\"\"", ";", "const", "char", "*", "src_template", ";", "const", "char", "*", "dst_template", ";", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "switch", "(", "CONST_INT_P", "(", "src", ")", "?", "GET_MODE", "(", "dest", ")", ":", "GET_MODE", "(", "src", ")", ")", "{", "case", "E_QImode", ":", "if", "(", "!", "REG_P", "(", "dest", ")", "||", "!", "CONST_INT_P", "(", "src", ")", ")", "extension", "=", "\".B\"", ";", "break", ";", "case", "E_HImode", ":", "if", "(", "!", "REG_P", "(", "dest", ")", "||", "!", "CONST_INT_P", "(", "src", ")", ")", "extension", "=", "\".W\"", ";", "break", ";", "case", "E_DFmode", ":", "case", "E_DImode", ":", "case", "E_SFmode", ":", "case", "E_SImode", ":", "extension", "=", "\".L\"", ";", "break", ";", "case", "E_VOIDmode", ":", "break", ";", "default", ":", "debug_rtx", "(", "src", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "MEM_P", "(", "src", ")", "&&", "rx_pid_data_operand", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "PID_UNENCODED", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "src", ")", "!=", "DImode", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "src", ")", "!=", "DFmode", ")", ";", "src_template", "=", "\"(%A1 - __pid_base)[%P1]\"", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", "&&", "rx_small_data_operand", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "src", ")", "!=", "DImode", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "src", ")", "!=", "DFmode", ")", ";", "src_template", "=", "\"%%gp(%A1)[%G1]\"", ";", "}", "else", "src_template", "=", "\"%1\"", ";", "if", "(", "MEM_P", "(", "dest", ")", "&&", "rx_small_data_operand", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "dest", ")", "!=", "DImode", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "dest", ")", "!=", "DFmode", ")", ";", "dst_template", "=", "\"%%gp(%A0)[%G0]\"", ";", "}", "else", "dst_template", "=", "\"%0\"", ";", "if", "(", "GET_MODE", "(", "dest", ")", "==", "DImode", "||", "GET_MODE", "(", "dest", ")", "==", "DFmode", ")", "{", "gcc_assert", "(", "!", "is_movu", ")", ";", "if", "(", "REG_P", "(", "src", ")", "&&", "REG_P", "(", "dest", ")", "&&", "(", "REGNO", "(", "dest", ")", "==", "REGNO", "(", "src", ")", "+", "1", ")", ")", "sprintf", "(", "out_template", ",", "\"mov.L\\t%%H1, %%H0 ! mov.L\\t%%1, %%0\"", ")", ";", "else", "sprintf", "(", "out_template", ",", "\"mov.L\\t%%1, %%0 ! mov.L\\t%%H1, %%H0\"", ")", ";", "}", "else", "sprintf", "(", "out_template", ",", "\"%s%s\\t%s, %s\"", ",", "is_movu", "?", "\"movu\"", ":", "\"mov\"", ",", "extension", ",", "src_template", ",", "dst_template", ")", ";", "return", "out_template", ";", "}", "</s>" ]

[ "Returns", "an", "assembler", "template", "for", "a", "move", "instruction", "." ]

[ "rx", "64", "\".L\"", "\"\"", "0", "1", "\".B\"", "\".W\"", "\".L\"", "0", "\"(%A1 - __pid_base)[%P1]\"", "0", "\"%%gp(%A1)[%G1]\"", "\"%1\"", "0", "\"%%gp(%A0)[%G0]\"", "\"%0\"", "1", "\"mov.L\\t%%H1, %%H0 ! mov.L\\t%%1, %%0\"", "\"mov.L\\t%%1, %%0 ! mov.L\\t%%H1, %%H0\"", "\"%s%s\\t%s, %s\"", "\"movu\"", "\"mov\"" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addFastRegAlloc", "(", ")", "{", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ")", ";", "insertPass", "(", "&", "TwoAddressInstructionPassID", ",", "&", "SIWholeQuadModeID", ")", ";", "insertPass", "(", "&", "TwoAddressInstructionPassID", ",", "&", "SIPreAllocateWWMRegsID", ")", ";", "TargetPassConfig", "::", "addFastRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

[ "AMDGPU", "SI", "SI", "SI" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastEmit_i", "(", "MVT", "Ty", ",", "MVT", "VT", ",", "unsigned", "Opc", ",", "uint64_t", "Imm", ")", "{", "if", "(", "Opc", "!=", "ISD", "::", "Constant", ")", "return", "0", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "Subtarget", "->", "useCRBits", "(", ")", ")", "{", "unsigned", "ImmReg", "=", "createResultReg", "(", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Imm", "==", "0", "?", "PPC", "::", "CRUNSET", ":", "PPC", "::", "CRSET", ")", ",", "ImmReg", ")", ";", "return", "ImmReg", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", "&&", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i1", ")", "return", "0", ";", "const", "TargetRegisterClass", "*", "RC", "=", "(", "(", "VT", "==", "MVT", "::", "i64", ")", "?", "&", "PPC", "::", "G8RCRegClass", ":", "&", "PPC", "::", "GPRCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "PPCMaterialize64BitInt", "(", "Imm", ",", "RC", ")", ";", "else", "return", "PPCMaterialize32BitInt", "(", "Imm", ",", "RC", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "request", "that", "an", "instruction", "with", "the", "given", "type", ",", "opcode", ",", "and", "immediate", "operand", "be", "emitted", "." ]

[ "PowerPC", "PPC", "ISD::Constant", "0", "MVT::i1", "PPC::CRBITRCRegClass", "0", "PPC::CRUNSET", "PPC::CRSET", "MVT::i64", "MVT::i32", "MVT::i16", "MVT::i8", "MVT::i1", "0", "MVT::i64", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "MVT::i64", "PPC", "PPC" ]

[]