Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "LC2200InstrInfo", "::", "loadImmediate", "(", "unsigned", "FrameReg", ",", "int64_t", "Imm", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "II", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "&", "NewImm", ")", "const", "{", "llvm_unreachable", "(", "\"not yet implemented loadImmediate()\"", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "LC2200", "LC2200", "\"not yet implemented loadImmediate()\"" ]

[]

[ "<s>", "void", "AArch64Subtarget", "::", "overrideSchedPolicy", "(", "MachineSchedPolicy", "&", "Policy", ",", "unsigned", "NumRegionInstrs", ")", "const", "{", "Policy", ".", "OnlyTopDown", "=", "false", ";", "Policy", ".", "OnlyBottomUp", "=", "false", ";", "Policy", ".", "DisableLatencyHeuristic", "=", "DisableLatencySchedHeuristic", ";", "}", "</s>" ]

[ "Override", "generic", "scheduling", "policy", "within", "a", "region", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "SDValue", "rvexTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"I am here!\\n\"", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "\"I am here!\\n\"", "\"Don't know how to custom lower this!\"", "ISD::GlobalAddress" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getCacheLineSize", "(", ")", "{", "if", "(", "CacheLineSize", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "return", "CacheLineSize", ";", "unsigned", "Directive", "=", "ST", "->", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", "||", "Directive", "==", "PPC", "::", "DIR_PWR9", ")", "return", "128", ";", "return", "64", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "PowerPC", "PPC", "0", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "128", "64" ]

[]

[ "<s>", "static", "bool", "ix86_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ";", "struct", "cl_target_option", "*", "cur_opt", ";", "HOST_WIDE_INT", "prev_isa", ";", "HOST_WIDE_INT", "cur_isa", ";", "HOST_WIDE_INT", "diff_isa", ";", "HOST_WIDE_INT", "prev_isa2", ";", "HOST_WIDE_INT", "cur_isa2", ";", "HOST_WIDE_INT", "diff_isa2", ";", "enum", "processor_type", "prev_arch", ";", "enum", "processor_type", "prev_tune", ";", "enum", "processor_type", "cur_arch", ";", "enum", "processor_type", "cur_tune", ";", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "pop_target", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "cur_tree", "=", "ix86_valid_target_attribute_tree", "(", "args", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "!", "cur_tree", "||", "cur_tree", "==", "error_mark_node", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ")", ";", "return", "false", ";", "}", "}", "target_option_current_node", "=", "cur_tree", ";", "ix86_reset_previous_fndecl", "(", ")", ";", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "prev_isa", "=", "prev_opt", "->", "x_ix86_isa_flags", ";", "cur_isa", "=", "cur_opt", "->", "x_ix86_isa_flags", ";", "diff_isa", "=", "(", "prev_isa", "^", "cur_isa", ")", ";", "prev_isa2", "=", "prev_opt", "->", "x_ix86_isa_flags2", ";", "cur_isa2", "=", "cur_opt", "->", "x_ix86_isa_flags2", ";", "diff_isa2", "=", "(", "prev_isa2", "^", "cur_isa2", ")", ";", "prev_arch", "=", "(", "enum", "processor_type", ")", "prev_opt", "->", "arch", ";", "prev_tune", "=", "(", "enum", "processor_type", ")", "prev_opt", "->", "tune", ";", "cur_arch", "=", "(", "enum", "processor_type", ")", "cur_opt", "->", "arch", ";", "cur_tune", "=", "(", "enum", "processor_type", ")", "cur_opt", "->", "tune", ";", "if", "(", "cur_arch", "==", "prev_arch", ")", "cur_arch", "=", "prev_arch", "=", "PROCESSOR_max", ";", "if", "(", "cur_tune", "==", "prev_tune", ")", "cur_tune", "=", "prev_tune", "=", "PROCESSOR_max", ";", "ix86_target_macros_internal", "(", "prev_isa", "&", "diff_isa", ",", "prev_isa2", "&", "diff_isa2", ",", "prev_arch", ",", "prev_tune", ",", "(", "enum", "fpmath_unit", ")", "prev_opt", "->", "x_ix86_fpmath", ",", "cpp_undef", ")", ";", "cpp_options", "*", "cpp_opts", "=", "cpp_get_options", "(", "parse_in", ")", ";", "unsigned", "char", "saved_warn_unused_macros", "=", "cpp_opts", "->", "warn_unused_macros", ";", "cpp_opts", "->", "warn_unused_macros", "=", "0", ";", "ix86_target_macros_internal", "(", "cur_isa", "&", "diff_isa", ",", "cur_isa2", "&", "diff_isa2", ",", "cur_arch", ",", "cur_tune", ",", "(", "enum", "fpmath_unit", ")", "cur_opt", "->", "x_ix86_fpmath", ",", "cpp_define", ")", ";", "cpp_opts", "->", "warn_unused_macros", "=", "saved_warn_unused_macros", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "i386", "0" ]

[]

[ "<s>", "int", "direct_return", "(", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "FALSE", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "m32r_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "return", "current_frame_info", ".", "total_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

[ "m32r", "0" ]

[]

[ "<s>", "void", "flushPendingInstructions", "(", "MCStreamer", "&", "Out", ")", "override", "{", "if", "(", "!", "inImplicitITBlock", "(", ")", ")", "{", "assert", "(", "PendingConditionalInsts", ".", "size", "(", ")", "==", "0", ")", ";", "return", ";", "}", "unsigned", "Mask", "=", "getITMaskEncoding", "(", ")", ";", "MCInst", "ITInst", ";", "ITInst", ".", "setOpcode", "(", "ARM", "::", "t2IT", ")", ";", "ITInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "ITState", ".", "Cond", ")", ")", ";", "ITInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Mask", ")", ")", ";", "Out", ".", "EmitInstruction", "(", "ITInst", ",", "getSTI", "(", ")", ")", ";", "assert", "(", "PendingConditionalInsts", ".", "size", "(", ")", "<=", "4", ")", ";", "for", "(", "const", "MCInst", "&", "Inst", ":", "PendingConditionalInsts", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "PendingConditionalInsts", ".", "clear", "(", ")", ";", "ITState", ".", "Mask", "=", "0", ";", "ITState", ".", "CurPosition", "=", "~", "0U", ";", "}", "</s>" ]

[ "Ensure", "that", "all", "previously", "parsed", "instructions", "have", "been", "emitted", "to", "the", "output", "streamer", ",", "if", "the", "target", "does", "not", "emit", "them", "immediately", "." ]

[ "ARM", "0", "ARM::t2IT", "4", "0", "0U" ]

[]

[ "<s>", "static", "void", "c6x_asm_emit_except_personality", "(", "rtx", "personality", ")", "{", "fputs", "(", "\"\\t.personality\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "personality", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_EMIT_EXCEPT_PERSONALITY", "." ]

[ "c6x", "\"\\t.personality\\t\"" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "isMemImm", "(", ")", "||", "isMemRegImm", "(", ")", "||", "isMemRegReg", "(", ")", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "DLX" ]

[]

[ "<s>", "FastISel", "*", "AArch64", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "FuncInfo", ",", "const", "TargetLibraryInfo", "*", "LibInfo", ")", "{", "return", "new", "AArch64FastISel", "(", "FuncInfo", ",", "LibInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "AArch64", "AArch64::createFastISel", "AArch64" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "MI", "&&", "\"Unable to get the legal offset for nil instruction.\"", ")", ";", "StackOffset", "SaveOffset", "(", "Offset", ",", "MVT", "::", "i8", ")", ";", "return", "isAArch64FrameOffsetLegal", "(", "*", "MI", ",", "SaveOffset", ")", "&", "AArch64FrameOffsetIsLegal", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "AArch64", "AArch64", "\"Unable to get the legal offset for nil instruction.\"", "MVT::i8", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "nios2_symbol_ref_in_r0rel_data_p", "(", "rtx", "sym", ")", "{", "tree", "decl", ";", "gcc_assert", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "sym", ")", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "sym", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "TARGET_ARCH_R2", "&&", "(", "TARGET_BYPASS_CACHE", "||", "TARGET_BYPASS_CACHE_VOLATILE", ")", ")", "return", "false", ";", "if", "(", "decl", "&&", "DECL_SECTION_NAME", "(", "decl", ")", ")", "return", "nios2_r0rel_section_name_p", "(", "DECL_SECTION_NAME", "(", "decl", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Likewise", "for", "r0-relative", "addressing", "." ]

[ "nios2", "0" ]

[]

[ "<s>", "bool", "PTXMFInfoExtract", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "unsigned", "RegType", ";", "if", "(", "TRC", "==", "PTX", "::", "RegPredRegisterClass", ")", "RegType", "=", "PTXRegisterType", "::", "Pred", ";", "else", "if", "(", "TRC", "==", "PTX", "::", "RegI16RegisterClass", ")", "RegType", "=", "PTXRegisterType", "::", "B16", ";", "else", "if", "(", "TRC", "==", "PTX", "::", "RegI32RegisterClass", ")", "RegType", "=", "PTXRegisterType", "::", "B32", ";", "else", "if", "(", "TRC", "==", "PTX", "::", "RegI64RegisterClass", ")", "RegType", "=", "PTXRegisterType", "::", "B64", ";", "else", "if", "(", "TRC", "==", "PTX", "::", "RegF32RegisterClass", ")", "RegType", "=", "PTXRegisterType", "::", "F32", ";", "else", "if", "(", "TRC", "==", "PTX", "::", "RegF64RegisterClass", ")", "RegType", "=", "PTXRegisterType", "::", "F64", ";", "else", "llvm_unreachable", "(", "\"Unkown register class.\"", ")", ";", "MFI", "->", "addRegister", "(", "Reg", ",", "RegType", ",", "PTXRegisterSpace", "::", "Reg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX", "0", "PTX::RegPredRegisterClass", "PTXRegisterType::Pred", "PTX::RegI16RegisterClass", "PTXRegisterType::B16", "PTX::RegI32RegisterClass", "PTXRegisterType::B32", "PTX::RegI64RegisterClass", "PTXRegisterType::B64", "PTX::RegF32RegisterClass", "PTXRegisterType::F32", "PTX::RegF64RegisterClass", "PTXRegisterType::F64", "\"Unkown register class.\"", "PTXRegisterSpace::Reg" ]

[]

[ "<s>", "bool", "SparcTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createSparcFPMoverPass", "(", "*", "this", ")", ")", ";", "PM", ".", "add", "(", "createSparcDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "static", "bool", "contains", "(", "uint16_t", "A", ",", "uint16_t", "B", ")", "{", "if", "(", "type", "(", "A", ")", "!=", "Code", ")", "return", "false", ";", "uint16_t", "KB", "=", "kind", "(", "B", ")", ";", "switch", "(", "kind", "(", "A", ")", ")", "{", "case", "Func", ":", "return", "KB", "==", "Block", ";", "case", "Block", ":", "return", "KB", "==", "Phi", "||", "KB", "==", "Stmt", ";", "case", "Phi", ":", "case", "Stmt", ":", "return", "type", "(", "B", ")", "==", "Ref", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "isUnconditionalBranch", "(", "unsigned", "int", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "Bimm16", ":", "case", "Mips", "::", "BimmX16", ":", "case", "Mips", "::", "JalB16", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "branch", "which", "always", "transfers", "control", "flow", "to", "some", "other", "block", "." ]

[ "Mips", "Mips::Bimm16", "Mips::BimmX16", "Mips::JalB16" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "IsBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "return", "Decoder", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "IsBranch", ",", "Offset", ",", "Width", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "Lanai" ]

[]

[ "<s>", "int", "m32c_expand_cmpstr", "(", "rtx", "*", "operands", ")", "{", "rtx", "src1a", ",", "src2a", ";", "src1a", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "src2a", "=", "XEXP", "(", "operands", "[", "2", "]", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src1a", ")", "!=", "REG", "||", "REGNO", "(", "src1a", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "src1a", "=", "copy_to_mode_reg", "(", "Pmode", ",", "src1a", ")", ";", "if", "(", "GET_CODE", "(", "src2a", ")", "!=", "REG", "||", "REGNO", "(", "src2a", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "src2a", "=", "copy_to_mode_reg", "(", "Pmode", ",", "src2a", ")", ";", "emit_insn", "(", "gen_cmpstrhi_op", "(", "src1a", ",", "src2a", ",", "src1a", ",", "src2a", ")", ")", ";", "emit_insn", "(", "gen_cond_to_int", "(", "operands", "[", "0", "]", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "This", "is", "a", "strcmp", "(", ")", "opcode", ".", "$", "0", "is", "the", "destination", "(", "HI", ")", "which", "holds", "<", "=", ">", "0", "depending", "on", "the", "comparison", ",", "$", "1", "is", "one", "string", "(", "MEM", ":", "BLK", ")", ",", "and", "$", "2", "is", "the", "other", "(", "MEM", ":", "BLK", ")", ".", "We", "must", "do", "the", "comparison", ",", "and", "then", "convert", "the", "flags", "to", "a", "signed", "integer", "result", "." ]

[ "m32c", "1", "0", "2", "0", "0", "1" ]

[]

[ "<s>", "bool", "AlphaFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Alpha", "Alpha" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonExpandPredSpillCode", "(", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ",", "false", ")", ";", "if", "(", "EnableGenMux", ")", "addPass", "(", "createHexagonGenMux", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "Align", "X86TargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "if", "(", "ML", "->", "isInnermost", "(", ")", "&&", "ExperimentalPrefInnermostLoopAlignment", ".", "getNumOccurrences", "(", ")", ")", "return", "Align", "(", "1ULL", "<<", "ExperimentalPrefInnermostLoopAlignment", ")", ";", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "1ULL" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"FixAllFDIVSQRT: Erratum Fix LBR34: fix FDIVS/FDIVD/FSQRTS/FSQRTD \"", "\"instructions with NOPs and floating-point store\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"FixAllFDIVSQRT: Erratum Fix LBR34: fix FDIVS/FDIVD/FSQRTS/FSQRTD \"", "\"instructions with NOPs and floating-point store\"" ]

[]

[ "<s>", "bool", "sh_dynamicalize_shift_p", "(", "rtx", "count", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "count", ")", ")", ";", "const", "int", "shift_amount_i", "=", "std", "::", "abs", "(", "INTVAL", "(", "count", ")", ")", "&", "31", ";", "int", "insn_count", ";", "if", "(", "shift_amount_i", "==", "31", ")", "insn_count", "=", "2", ";", "else", "insn_count", "=", "ashl_lshr_seq", "[", "shift_amount_i", "]", ".", "insn_count", ";", "return", "TARGET_DYNSHIFT", "&&", "(", "insn_count", ">", "1", "+", "SH_DYNAMIC_SHIFT_COST", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "potentially", "beneficial", "to", "use", "a", "dynamic", "shift", "instruction", "(", "shad", "/", "shar", ")", "instead", "of", "a", "combination", "of", "1/2/8/16", "shift", "instructions", "for", "the", "specified", "shift", "count", ".", "If", "dynamic", "shifts", "are", "not", "available", ",", "always", "return", "false", "." ]

[ "sh", "31", "31", "2", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldAlignPointerArgs", "(", "CallInst", "*", "CI", ",", "unsigned", "&", "MinSize", ",", "unsigned", "&", "PrefAlign", ")", "const", "{", "if", "(", "!", "isa", "<", "MemIntrinsic", ">", "(", "CI", ")", ")", "return", "false", ";", "MinSize", "=", "8", ";", "PrefAlign", "=", "(", "Subtarget", "->", "hasV6Ops", "(", ")", "&&", "!", "Subtarget", "->", "isMClass", "(", ")", "?", "8", ":", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "pointer", "arguments", "to", "CI", "should", "be", "aligned", "by", "aligning", "the", "object", "whose", "address", "is", "being", "passed", "." ]

[ "ARM", "ARM", "8", "8", "4" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKDOWN", ")", "{", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKUP", ")", "{", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "Hexagon", "Hexagon", "Hexagon::ADJCALLSTACKDOWN", "Hexagon::ADJCALLSTACKUP", "\"Cannot handle this call frame pseudo instruction\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Vector Registers Merge Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"R600 Vector Registers Merge Pass\"" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "MOSInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "MOS", "::", "MO_LO", ",", "\"lo\"", "}", ",", "{", "MOS", "::", "MO_HI", ",", "\"hi\"", "}", ",", "{", "MOS", "::", "MO_HI_JT", ",", "\"hi-jt\"", "}", "}", ";", "return", "Flags", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "MOS", "MOS", "MOS::MO_LO", "\"lo\"", "MOS::MO_HI", "\"hi\"", "MOS::MO_HI_JT", "\"hi-jt\"" ]

[]

[ "<s>", "int", "easy_di_const", "(", "rtx", "op", ")", "{", "rtx", "high_rtx", ",", "low_rtx", ";", "HOST_WIDE_INT", "high", ",", "low", ";", "split_double", "(", "op", ",", "&", "high_rtx", ",", "&", "low_rtx", ")", ";", "high", "=", "INTVAL", "(", "high_rtx", ")", ";", "low", "=", "INTVAL", "(", "low_rtx", ")", ";", "if", "(", "high", ">=", "-", "128", "&&", "high", "<=", "127", "&&", "low", ">=", "-", "128", "&&", "low", "<=", "127", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "DImode", "const", "we", "want", "to", "handle", "inline", ".", "This", "must", "match", "the", "code", "in", "the", "movdi", "pattern", ".", "It", "is", "used", "by", "the", "'", "G", "'", "CONST_DOUBLE_OK_FOR_LETTER", "." ]

[ "m32r", "128", "127", "128", "127", "1", "0" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "DebugLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot be called directly\"" ]

[]

[ "<s>", "bool", "WebAssembly", "::", "mayThrow", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "THROW", ":", "case", "WebAssembly", "::", "THROW_S", ":", "case", "WebAssembly", "::", "RETHROW", ":", "case", "WebAssembly", "::", "RETHROW_S", ":", "return", "true", ";", "}", "if", "(", "isCallIndirect", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "getCalleeOp", "(", "MI", ")", ";", "assert", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", ";", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"memcpy\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"memmove\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"memset\"", ")", "==", "0", ")", "return", "false", ";", "return", "true", ";", "}", "const", "auto", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "F", ")", "return", "true", ";", "if", "(", "F", "->", "doesNotThrow", "(", ")", ")", "return", "false", ";", "if", "(", "F", "->", "getName", "(", ")", "==", "CxaBeginCatchFn", "||", "F", "->", "getName", "(", ")", "==", "PersonalityWrapperFn", "||", "F", "->", "getName", "(", ")", "==", "ClangCallTerminateFn", "||", "F", "->", "getName", "(", ")", "==", "StdTerminateFn", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "may", "throw", "an", "exception", "." ]

[ "WebAssembly", "WebAssembly::mayThrow", "WebAssembly::THROW", "WebAssembly::THROW_S", "WebAssembly::RETHROW", "WebAssembly::RETHROW_S", "\"memcpy\"", "0", "\"memmove\"", "0", "\"memset\"", "0" ]

[]

[ "<s>", "static", "rtx", "function_arg_32", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "machine_mode", "orig_mode", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "bytes", ",", "HOST_WIDE_INT", "words", ")", "{", "bool", "error_p", "=", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "constm1_rtx", ";", "if", "(", "TARGET_IAMCU", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "bytes", "<=", "8", ")", "goto", "pass_in_reg", ";", "return", "NULL_RTX", ";", "}", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_BLKmode", ":", "if", "(", "bytes", "<", "0", ")", "break", ";", "case", "E_DImode", ":", "case", "E_SImode", ":", "case", "E_HImode", ":", "case", "E_QImode", ":", "pass_in_reg", ":", "if", "(", "words", "<=", "cum", "->", "nregs", ")", "{", "int", "regno", "=", "cum", "->", "regno", ";", "if", "(", "cum", "->", "fastcall", ")", "{", "if", "(", "mode", "==", "BLKmode", "||", "mode", "==", "DImode", "||", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", ")", "break", ";", "if", "(", "regno", "==", "AX_REG", ")", "regno", "=", "CX_REG", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "break", ";", "case", "E_DFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "2", ")", "break", ";", "case", "E_SFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "1", ")", "break", ";", "case", "E_TImode", ":", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V8HFmode", ":", "case", "E_V8BFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "cum", "->", "sse_nregs", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "orig_mode", ",", "cum", "->", "sse_regno", "+", "FIRST_SSE_REG", ")", ";", "}", "break", ";", "case", "E_OImode", ":", "case", "E_XImode", ":", "gcc_unreachable", "(", ")", ";", "case", "E_V64QImode", ":", "case", "E_V32HImode", ":", "case", "E_V16SImode", ":", "case", "E_V8DImode", ":", "case", "E_V32HFmode", ":", "case", "E_V32BFmode", ":", "case", "E_V16SFmode", ":", "case", "E_V8DFmode", ":", "case", "E_V16HFmode", ":", "case", "E_V16BFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V32QImode", ":", "case", "E_V16HImode", ":", "case", "E_V4DFmode", ":", "case", "E_V4DImode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "cum", "->", "sse_nregs", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "orig_mode", ",", "cum", "->", "sse_regno", "+", "FIRST_SSE_REG", ")", ";", "}", "break", ";", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "case", "E_V4HFmode", ":", "case", "E_V4BFmode", ":", "case", "E_V2SImode", ":", "case", "E_V2SFmode", ":", "case", "E_V1TImode", ":", "case", "E_V1DImode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "cum", "->", "mmx_nregs", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "orig_mode", ",", "cum", "->", "mmx_regno", "+", "FIRST_MMX_REG", ")", ";", "}", "break", ";", "}", "if", "(", "error_p", ")", "{", "cum", "->", "float_in_sse", "=", "0", ";", "error", "(", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", ",", "cum", "->", "decl", ")", ";", "sorry", "(", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</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", ")", "." ]

[ "i386", "8", "0", "1", "2", "1", "1", "0", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"" ]

[]

[ "<s>", "static", "tree", "check_op_callback", "(", "tree", "*", "tp", ",", "int", "*", "walk_subtrees", ",", "void", "*", "data", ")", "{", "struct", "walk_stmt_info", "*", "wi", "=", "(", "struct", "walk_stmt_info", "*", ")", "data", ";", "if", "(", "RECORD_OR_UNION_TYPE_P", "(", "*", "tp", ")", "||", "TREE_CODE", "(", "*", "tp", ")", "==", "ENUMERAL_TYPE", ")", "{", "if", "(", "TREE_TYPE", "(", "*", "tp", ")", "==", "NULL", ")", "return", "NULL", ";", "}", "if", "(", "TREE_TYPE", "(", "*", "tp", ")", "==", "NULL", ")", "return", "NULL", ";", "const", "tree", "type", "=", "TREE_TYPE", "(", "*", "tp", ")", ";", "gcall", "*", "call", "=", "dyn_cast", "<", "gcall", "*", ">", "(", "gsi_stmt", "(", "wi", "->", "gsi", ")", ")", ";", "if", "(", "call", "&&", "tp", "==", "gimple_call_fn_ptr", "(", "call", ")", "&&", "gimple_call_fndecl", "(", "call", ")", ")", "return", "NULL", ";", "switch", "(", "TREE_CODE", "(", "type", ")", ")", "{", "case", "FUNCTION_TYPE", ":", "case", "METHOD_TYPE", ":", "{", "for", "(", "tree", "p", "=", "TYPE_ARG_TYPES", "(", "type", ")", ";", "p", ";", "p", "=", "TREE_CHAIN", "(", "p", ")", ")", "{", "tree", "arg_type", "=", "TREE_VALUE", "(", "p", ")", ";", "if", "(", "chkp_type_has_function_pointer", "(", "arg_type", ")", ")", "error_at", "(", "gimple_location", "(", "wi", "->", "stmt", ")", ",", "\"function pointers \"", "\"not supported with %<-mabi=ti%> option\"", ")", ";", "}", "break", ";", "}", "case", "RECORD_TYPE", ":", "case", "UNION_TYPE", ":", "case", "QUAL_UNION_TYPE", ":", "case", "POINTER_TYPE", ":", "{", "if", "(", "chkp_type_has_function_pointer", "(", "type", ")", ")", "{", "error_at", "(", "gimple_location", "(", "wi", "->", "stmt", ")", ",", "\"function pointers not supported with \"", "\"%<-mabi=ti%> option\"", ")", ";", "*", "walk_subtrees", "=", "false", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Callback", "for", "walk_gimple_seq", "that", "checks", "TP", "tree", "for", "TI", "ABI", "compliance", "." ]

[ "pru", "\"function pointers \"", "\"not supported with %<-mabi=ti%> option\"", "\"function pointers not supported with \"", "\"%<-mabi=ti%> option\"" ]

[]

[ "<s>", "void", "rs6000_emit_le_vsx_permute", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "!", "altivec_indexed_or_indirect_operand", "(", "dest", ",", "mode", ")", ")", ";", "gcc_assert", "(", "!", "altivec_indexed_or_indirect_operand", "(", "source", ",", "mode", ")", ")", ";", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "{", "dest", "=", "gen_lowpart", "(", "V1TImode", ",", "dest", ")", ";", "source", "=", "gen_lowpart", "(", "V1TImode", ",", "source", ")", ";", "mode", "=", "V1TImode", ";", "}", "if", "(", "mode", "==", "TImode", "||", "mode", "==", "V1TImode", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_ROTATE", "(", "mode", ",", "source", ",", "GEN_INT", "(", "64", ")", ")", ")", ")", ";", "else", "{", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rs6000_const_vec", "(", "mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_VEC_SELECT", "(", "mode", ",", "source", ",", "par", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "an", "lxvd2x", ",", "stxvd2x", ",", "or", "xxpermdi", "instruction", "for", "a", "VSX", "load", "or", "store", "operation", "." ]

[ "rs6000", "64" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_recurse", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "tree", "f", ";", "for", "(", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "DECL_CHAIN", "(", "f", ")", ")", "if", "(", "TREE_CODE", "(", "f", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "tree", "ftype", "=", "TREE_TYPE", "(", "f", ")", ";", "machine_mode", "mode", ";", "if", "(", "ftype", "==", "error_mark_node", ")", "continue", ";", "mode", "=", "TYPE_MODE", "(", "ftype", ")", ";", "if", "(", "DECL_SIZE", "(", "f", ")", "!=", "0", "&&", "tree_fits_uhwi_p", "(", "bit_position", "(", "f", ")", ")", ")", "bitpos", "+=", "int_bit_position", "(", "f", ")", ";", "if", "(", "TREE_CODE", "(", "ftype", ")", "==", "RECORD_TYPE", ")", "rs6000_darwin64_record_arg_recurse", "(", "cum", ",", "ftype", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "else", "if", "(", "cum", "->", "named", "&&", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ")", ")", "{", "unsigned", "n_fpreg", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", ">>", "3", ";", "switch", "(", "mode", ")", "{", "case", "E_SCmode", ":", "mode", "=", "SFmode", ";", "break", ";", "case", "E_DCmode", ":", "mode", "=", "DFmode", ";", "break", ";", "case", "E_TCmode", ":", "mode", "=", "TFmode", ";", "break", ";", "default", ":", "break", ";", "}", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "if", "(", "cum", "->", "fregno", "+", "n_fpreg", ">", "FP_ARG_MAX_REG", "+", "1", ")", "{", "gcc_assert", "(", "cum", "->", "fregno", "==", "FP_ARG_MAX_REG", "&&", "(", "mode", "==", "TFmode", "||", "mode", "==", "TDmode", ")", ")", ";", "mode", "=", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "?", "DDmode", ":", "DFmode", ";", "cum", "->", "use_stack", "=", "1", ";", "}", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "fregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "if", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "cum", "->", "fregno", "++", ";", "}", "else", "if", "(", "cum", "->", "named", "&&", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "1", ")", ")", "{", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "vregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "}", "else", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "cum", "->", "intoffset", "=", "bitpos", ";", "}", "}", "</s>" ]

[ "Recursive", "workhorse", "for", "the", "following", "." ]

[ "powerpcspe", "0", "7", "3", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "MCExpr", "*", "MipsTargetObjectFile", "::", "getDebugThreadLocalSymbol", "(", "const", "MCSymbol", "*", "Sym", ")", "const", "{", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "0x8000", ",", "getContext", "(", ")", ")", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Describe", "a", "TLS", "variable", "address", "within", "debug", "info", "." ]

[ "Mips", "Mips", "0x8000" ]

[]

[ "<s>", "static", "rtx", "avr_function_value", "(", "const_tree", "type", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "offs", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "!=", "BLKmode", ")", "return", "avr_libcall_value", "(", "TYPE_MODE", "(", "type", ")", ",", "NULL_RTX", ")", ";", "offs", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "offs", "<", "2", ")", "offs", "=", "2", ";", "if", "(", "offs", ">", "2", "&&", "offs", "<", "GET_MODE_SIZE", "(", "SImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "else", "if", "(", "offs", ">", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "offs", "<", "GET_MODE_SIZE", "(", "DImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "return", "gen_rtx_REG", "(", "BLKmode", ",", "avr_ret_register", "(", ")", "+", "2", "-", "offs", ")", ";", "}", "</s>" ]

[ "Create", "an", "RTX", "representing", "the", "place", "where", "a", "function", "returns", "a", "value", "of", "data", "type", "VALTYPE", "." ]

[ "avr", "2", "2", "2", "2" ]

[]

[ "<s>", "unsigned", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "Hexagon", "::", "R1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "Hexagon", "Hexagon::R1" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canUseAsEpilogue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "MBB", ".", "getParent", "(", ")", "&&", "\"Block is not attached to a function!\"", ")", ";", "if", "(", "STI", ".", "isTargetWin64", "(", ")", "&&", "!", "MBB", ".", "succ_empty", "(", ")", "&&", "!", "MBB", ".", "isReturnBlock", "(", ")", ")", "return", "false", ";", "if", "(", "canUseLEAForSPInEpilogue", "(", "*", "MBB", ".", "getParent", "(", ")", ")", ")", "return", "true", ";", "return", "!", "flagsNeedToBePreservedBeforeTheTerminators", "(", "MBB", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "epilogue", "for", "the", "target", "." ]

[ "X86", "X86", "\"Block is not attached to a function!\"" ]

[]

[ "<s>", "void", "PPCTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "ST", "->", "getMcpu", "(", ")", "==", "PPC", "::", "MCPU_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "}", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "PowerPC", "PPC", "PPC::MCPU_A2" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "StackProtector", ">", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX" ]

[]

[ "<s>", "rtx", "alpha_gp_save_rtx", "(", "void", ")", "{", "rtx_insn", "*", "seq", ";", "rtx", "m", "=", "cfun", "->", "machine", "->", "gp_save_rtx", ";", "if", "(", "m", "==", "NULL", ")", "{", "start_sequence", "(", ")", ";", "m", "=", "assign_stack_local", "(", "DImode", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ")", ";", "m", "=", "validize_mem", "(", "m", ")", ";", "emit_move_insn", "(", "m", ",", "pic_offset_table_rtx", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "insert_insn_on_edge", "(", "seq", ",", "single_succ_edge", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ")", ";", "cfun", "->", "machine", "->", "gp_save_rtx", "=", "m", ";", "}", "return", "m", ";", "}", "</s>" ]

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

[ "alpha" ]

[]

[ "<s>", "const", "uint32_t", "*", "SystemZRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_SystemZ_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "Subtarget", ".", "hasVector", "(", ")", "?", "CSR_SystemZ_AllRegs_Vector_RegMask", ":", "CSR_SystemZ_AllRegs_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_RegMask", ";", "return", "CSR_SystemZ_RegMask", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Alpha", "::", "F4RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "F8RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDT", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "GPRCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDQ", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "llvm_unreachable", "(", "\"Unhandled register class\"", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::F4RCRegisterClass", "Alpha::LDS", "Alpha::F31", "Alpha::F8RCRegisterClass", "Alpha::LDT", "Alpha::F31", "Alpha::GPRCRegisterClass", "Alpha::LDQ", "Alpha::F31", "\"Unhandled register class\"" ]

[]

[ "<s>", "const", "LatticeCell", "&", "get", "(", "unsigned", "R", ")", "const", "{", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "R", ")", ")", "return", "Bottom", ";", "MapType", "::", "const_iterator", "F", "=", "Map", ".", "find", "(", "R", ")", ";", "if", "(", "F", "!=", "Map", ".", "end", "(", ")", ")", "return", "F", "->", "second", ";", "return", "Top", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "s390_execute_label", "(", "rtx", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_EXECUTE", ")", "return", "XVECEXP", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ",", "0", ",", "2", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Check", "whether", "INSN", "is", "an", "execute", ".", "Return", "the", "label_ref", "to", "its", "execute", "target", "template", "if", "so", ",", "NULL_RTX", "otherwise", "." ]

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

[]

[ "<s>", "static", "void", "nds32_emit_stack_v3pop", "(", "rtx", "Rb", ",", "rtx", "Re", ",", "rtx", "En4", "ATTRIBUTE_UNUSED", ",", "rtx", "imm8u", ")", "{", "int", "regno", ";", "int", "num_use_regs", ";", "int", "par_index", ";", "int", "offset", ";", "rtx", "reg", ";", "rtx", "mem", ";", "rtx", "pop_rtx", ";", "rtx", "adjust_sp_rtx", ";", "rtx", "parallel_insn", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "num_use_regs", "=", "REGNO", "(", "Re", ")", "-", "REGNO", "(", "Rb", ")", "+", "1", "+", "3", ";", "parallel_insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_use_regs", "+", "1", ")", ")", ";", "par_index", "=", "0", ";", "offset", "=", "0", ";", "for", "(", "regno", "=", "REGNO", "(", "Rb", ")", ";", "regno", "<=", "(", "int", ")", "REGNO", "(", "Re", ")", ";", "regno", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "}", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "FP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "LP_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "pop_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "pop_rtx", ";", "RTX_FRAME_RELATED_P", "(", "pop_rtx", ")", "=", "1", ";", "offset", "=", "offset", "+", "4", ";", "par_index", "++", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "adjust_sp_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", "+", "INTVAL", "(", "imm8u", ")", ")", ")", ";", "XVECEXP", "(", "parallel_insn", ",", "0", ",", "par_index", ")", "=", "adjust_sp_rtx", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_ADJUST_CFA", ",", "copy_rtx", "(", "adjust_sp_rtx", ")", ",", "dwarf", ")", ";", "parallel_insn", "=", "emit_insn", "(", "parallel_insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "parallel_insn", ")", "=", "1", ";", "REG_NOTES", "(", "parallel_insn", ")", "=", "dwarf", ";", "}", "</s>" ]

[ "Function", "to", "create", "a", "parallel", "rtx", "pattern", "which", "presents", "stack", "v3pop", "behavior", ".", "The", "overall", "concept", "are", ":", "``", "pop", "registers", "from", "memory", "''", ",", "``", "adjust", "stack", "pointer", "''", "." ]

[ "nds32", "1", "3", "1", "0", "0", "0", "1", "4", "0", "1", "4", "0", "1", "4", "0", "1", "4", "0", "1" ]

[]

[ "<s>", "static", "void", "tilegx_expand_unaligned_store", "(", "rtx", "mem", ",", "rtx", "src", ",", "HOST_WIDE_INT", "bitsize", ",", "HOST_WIDE_INT", "bit_offset", ")", "{", "HOST_WIDE_INT", "byte_offset", "=", "bit_offset", "/", "BITS_PER_UNIT", ";", "HOST_WIDE_INT", "bytesize", "=", "bitsize", "/", "BITS_PER_UNIT", ";", "HOST_WIDE_INT", "shift_init", ",", "shift_increment", ",", "shift_amt", ";", "HOST_WIDE_INT", "i", ";", "rtx", "mem_addr", ";", "rtx", "store_val", ";", "shift_init", "=", "BYTES_BIG_ENDIAN", "?", "(", "bitsize", "-", "BITS_PER_UNIT", ")", ":", "0", ";", "shift_increment", "=", "BYTES_BIG_ENDIAN", "?", "-", "BITS_PER_UNIT", ":", "BITS_PER_UNIT", ";", "for", "(", "i", "=", "0", ",", "shift_amt", "=", "shift_init", ";", "i", "<", "bytesize", ";", "i", "++", ",", "shift_amt", "+=", "shift_increment", ")", "{", "mem_addr", "=", "adjust_address", "(", "mem", ",", "QImode", ",", "byte_offset", "+", "i", ")", ";", "if", "(", "shift_amt", ")", "{", "store_val", "=", "expand_simple_binop", "(", "DImode", ",", "LSHIFTRT", ",", "gen_lowpart", "(", "DImode", ",", "src", ")", ",", "GEN_INT", "(", "shift_amt", ")", ",", "NULL", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "store_val", "=", "gen_lowpart", "(", "QImode", ",", "store_val", ")", ";", "}", "else", "{", "store_val", "=", "gen_lowpart", "(", "QImode", ",", "src", ")", ";", "}", "emit_move_insn", "(", "mem_addr", ",", "store_val", ")", ";", "}", "}", "</s>" ]

[ "Expand", "unaligned", "stores", "." ]

[ "tilegx", "0", "0", "1" ]

[]

[ "<s>", "void", "sparc_emit_membar_for_model", "(", "enum", "memmodel", "model", ",", "int", "load_store", ",", "int", "before_after", ")", "{", "const", "int", "LoadLoad", "=", "1", ";", "const", "int", "StoreLoad", "=", "2", ";", "const", "int", "LoadStore", "=", "4", ";", "const", "int", "StoreStore", "=", "8", ";", "int", "mm", "=", "0", ",", "implied", "=", "0", ";", "switch", "(", "sparc_memory_model", ")", "{", "case", "SMM_SC", ":", "implied", "=", "LoadLoad", "|", "StoreLoad", "|", "LoadStore", "|", "StoreStore", ";", "break", ";", "case", "SMM_TSO", ":", "implied", "|=", "StoreStore", ";", "if", "(", "load_store", "==", "3", "&&", "before_after", "==", "1", ")", "implied", "|=", "StoreLoad", ";", "case", "SMM_PSO", ":", "implied", "|=", "LoadLoad", "|", "LoadStore", ";", "if", "(", "load_store", "==", "3", "&&", "before_after", "==", "2", ")", "implied", "|=", "StoreLoad", "|", "StoreStore", ";", "case", "SMM_RMO", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "before_after", "&", "1", ")", "{", "if", "(", "model", "==", "MEMMODEL_RELEASE", "||", "model", "==", "MEMMODEL_ACQ_REL", "||", "model", "==", "MEMMODEL_SEQ_CST", ")", "{", "if", "(", "load_store", "&", "1", ")", "mm", "|=", "LoadLoad", "|", "StoreLoad", ";", "if", "(", "load_store", "&", "2", ")", "mm", "|=", "LoadStore", "|", "StoreStore", ";", "}", "}", "if", "(", "before_after", "&", "2", ")", "{", "if", "(", "model", "==", "MEMMODEL_ACQUIRE", "||", "model", "==", "MEMMODEL_ACQ_REL", "||", "model", "==", "MEMMODEL_SEQ_CST", ")", "{", "if", "(", "load_store", "&", "1", ")", "mm", "|=", "LoadLoad", "|", "LoadStore", ";", "if", "(", "load_store", "&", "2", ")", "mm", "|=", "StoreLoad", "|", "StoreStore", ";", "}", "}", "mm", "&=", "~", "implied", ";", "if", "(", "mm", "||", "before_after", "==", "3", ")", "emit_insn", "(", "gen_membar", "(", "GEN_INT", "(", "mm", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "membar", "instruction", "for", "various", "use", "cases", ".", "Both", "the", "LOAD_STORE", "and", "BEFORE_AFTER", "arguments", "of", "the", "form", "X_Y", ".", "They", "are", "two-bit", "masks", "where", "bit", "0", "indicates", "that", "X", "is", "true", ",", "and", "bit", "1", "indicates", "Y", "is", "true", "." ]

[ "sparc", "1", "2", "4", "8", "0", "0", "3", "1", "3", "2", "1", "1", "2", "2", "1", "2", "3" ]

[]

[ "<s>", "static", "bool", "rs6000_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_TOCREL", ":", "gcc_checking_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "REG_P", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "&&", "REGNO", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", "==", "TOC_REGISTER", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "if", "(", "x", "==", "tocrel_base_oac", "&&", "tocrel_offset_oac", "!=", "const0_rtx", ")", "{", "if", "(", "INTVAL", "(", "tocrel_offset_oac", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_offset_oac", ")", ")", ";", "}", "if", "(", "!", "TARGET_AIX", "||", "(", "TARGET_ELF", "&&", "TARGET_MINIMAL_TOC", ")", ")", "{", "putc", "(", "'-'", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "toc_label_name", ")", ";", "need_toc_init", "=", "1", ";", "}", "else", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@toc\"", ",", "file", ")", ";", "return", "true", ";", "case", "UNSPEC_MACHOPIC_OFFSET", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "putc", "(", "'-'", ",", "file", ")", ";", "machopic_output_function_base_name", "(", "file", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "rs6000", "1", "0", "0", "0", "1", "0", "1", "0", "0", "0", "\"+\"", "1", "\"@toc\"", "0", "0" ]

[]

[ "<s>", "bool", "aarch64_regno_ok_for_base_p", "(", "int", "regno", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "{", "if", "(", "!", "strict_p", ")", "return", "true", ";", "if", "(", "!", "reg_renumber", ")", "return", "false", ";", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "}", "return", "(", "GP_REGNUM_P", "(", "regno", ")", "||", "regno", "==", "SP_REGNUM", "||", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "REGNO", "is", "a", "valid", "base", "register", "for", "mode", "MODE", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "TOYTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_TOY", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "TOYISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "TOY", "TOY", "ISD::OutputArg", "\"VarArg not supported\"", "16", "TOY", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "TOYISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_exact_insn", "(", "insn_code", "icode", ")", "{", "unsigned", "int", "nops", "=", "insn_data", "[", "icode", "]", ".", "n_operands", ";", "if", "(", "!", "function_returns_void_p", "(", ")", ")", "{", "add_output_operand", "(", "icode", ")", ";", "nops", "-=", "1", ";", "}", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "nops", ";", "++", "i", ")", "add_input_operand", "(", "icode", ",", "args", "[", "i", "]", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "with", "a", "1:1", "mapping", "between", "arguments", "and", "input", "operands", "." ]

[ "aarch64", "1", "0" ]

[]

[ "<s>", "static", "rtx", "nds32_expand_builtin_null_ftype_reg_imm", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "struct", "expand_operand", "ops", "[", "2", "]", ";", "tree", "arg0", ",", "arg1", ";", "rtx", "value0", ",", "value1", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "value0", "=", "expand_normal", "(", "arg0", ")", ";", "value1", "=", "expand_normal", "(", "arg1", ")", ";", "create_input_operand", "(", "&", "ops", "[", "0", "]", ",", "value0", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "value1", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg1", ")", ")", ")", ";", "if", "(", "!", "maybe_expand_insn", "(", "icode", ",", "2", ",", "ops", ")", ")", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Function", "to", "expand", "builtin", "function", "for", "'", "[", "(", "unspec_volatile", "[", "(", "reg", ")", "(", "imm", ")", "]", ")", "]", "'", "pattern", "." ]

[ "nds32", "2", "0", "1", "0", "1", "2", "\"invalid argument to built-in function\"" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "STI", ".", "isTargetIOS", "(", ")", "||", "STI", ".", "isTargetWatchOS", "(", ")", ")", "return", "true", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ";", "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Mips", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Mips", "::", "MoveR3216", ";", "else", "if", "(", "Mips", "::", "CPURegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Mips", "::", "Move32R16", ";", "else", "if", "(", "(", "SrcReg", "==", "Mips", "::", "HI", ")", "&&", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ")", "Opc", "=", "Mips", "::", "Mfhi16", ",", "SrcReg", "=", "0", ";", "else", "if", "(", "(", "SrcReg", "==", "Mips", "::", "LO", ")", "&&", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ")", "Opc", "=", "Mips", "::", "Mflo16", ",", "SrcReg", "=", "0", ";", "assert", "(", "Opc", "&&", "\"Cannot copy registers\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Mips", "Mips", "0", "Mips::CPU16RegsRegClass", "Mips::CPURegsRegClass", "Mips::MoveR3216", "Mips::CPURegsRegClass", "Mips::CPU16RegsRegClass", "Mips::Move32R16", "Mips::HI", "Mips::CPU16RegsRegClass", "Mips::Mfhi16", "0", "Mips::LO", "Mips::CPU16RegsRegClass", "Mips::Mflo16", "0", "\"Cannot copy registers\"" ]

[]

[ "<s>", "bool", "hasTailCall", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpc", "=", "I", "->", "getOpcode", "(", ")", ";", "return", "RetOpc", "==", "Hexagon", "::", "PS_tailcall_i", "||", "RetOpc", "==", "Hexagon", "::", "PS_tailcall_r", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "function", "contains", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon::PS_tailcall_i", "Hexagon::PS_tailcall_r" ]

[]

[ "<s>", "static", "rtx", "function_value_32", "(", "machine_mode", "orig_mode", ",", "machine_mode", "mode", ",", "const_tree", "fntype", ",", "const_tree", "fn", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "regno", "=", "FIRST_MMX_REG", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", ")", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_FLOAT_RETURNS_IN_80387", ")", "regno", "=", "FIRST_FLOAT_REG", ";", "else", "regno", "=", "AX_REG", ";", "if", "(", "(", "fn", "||", "fntype", ")", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "{", "int", "sse_level", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fn", ",", "false", ")", ";", "if", "(", "(", "sse_level", ">=", "1", "&&", "mode", "==", "SFmode", ")", "||", "(", "sse_level", "==", "2", "&&", "mode", "==", "DFmode", ")", ")", "regno", "=", "FIRST_SSE_REG", ";", "}", "gcc_assert", "(", "mode", "!=", "OImode", ")", ";", "return", "gen_rtx_REG", "(", "orig_mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", "." ]

[ "i386", "8", "16", "32", "64", "1", "2" ]

[]

[ "<s>", "bool", "hasAndNotCompare", "(", "SDValue", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "should", "transform", ":", "(", "X", "&", "Y", ")", "==", "Y", "�", "?", "(", "~X", "&", "Y", ")", "==", "0", "(", "X", "&", "Y", ")", "!", "=", "Y", "�", "?", "(", "~X", "&", "Y", ")", "!", "=", "0", "." ]

[ "AArch64" ]

[]

[ "<s>", "PreservedAnalyses", "AMDGPUPropagateAttributesLatePass", "::", "run", "(", "Module", "&", "M", ",", "ModuleAnalysisManager", "&", "AM", ")", "{", "return", "AMDGPUPropagateAttributes", "(", "&", "TM", ",", "true", ")", ".", "process", "(", "M", ")", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

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

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR32RegClass", "||", "RC", "==", "&", "SystemZ", "::", "ADDR32RegClass", ")", "Opc", "=", "SystemZ", "::", "MOV32mr", ";", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR64RegClass", "||", "RC", "==", "&", "SystemZ", "::", "ADDR64RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV64mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "FP32RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "FMOV32mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "FP64RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "FMOV64mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR64PRegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV64Pmr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR128RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV128mr", ";", "}", "else", "llvm_unreachable", "(", "\"Unsupported regclass to store\"", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "SystemZ", "SystemZ", "0", "SystemZ::GR32RegClass", "SystemZ::ADDR32RegClass", "SystemZ::MOV32mr", "SystemZ::GR64RegClass", "SystemZ::ADDR64RegClass", "SystemZ::MOV64mr", "SystemZ::FP32RegClass", "SystemZ::FMOV32mr", "SystemZ::FP64RegClass", "SystemZ::FMOV64mr", "SystemZ::GR64PRegClass", "SystemZ::MOV64Pmr", "SystemZ::GR128RegClass", "SystemZ::MOV128mr", "\"Unsupported regclass to store\"" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "SmallPIC", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::G8RC_and_G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "ExpandMLx", "&&", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "Subtarget", ".", "hasVFP2", "(", ")", ")", "PM", ".", "add", "(", "createMLxExpansionPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "static", "const", "char", "*", "s390_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "bool", "bool1_p", ",", "bool2_p", ";", "bool", "plusminus_p", ";", "bool", "muldiv_p", ";", "bool", "compare_p", ";", "machine_mode", "mode1", ",", "mode2", ";", "if", "(", "!", "TARGET_ZVECTOR", ")", "return", "NULL", ";", "if", "(", "!", "VECTOR_TYPE_P", "(", "type1", ")", "||", "!", "VECTOR_TYPE_P", "(", "type2", ")", ")", "return", "NULL", ";", "bool1_p", "=", "s390_vector_bool_type_p", "(", "type1", ")", ";", "bool2_p", "=", "s390_vector_bool_type_p", "(", "type2", ")", ";", "if", "(", "!", "bool1_p", "&&", "!", "bool2_p", "&&", "TYPE_UNSIGNED", "(", "type1", ")", "!=", "TYPE_UNSIGNED", "(", "type2", ")", ")", "return", "N_", "(", "\"types differ in signedness\"", ")", ";", "plusminus_p", "=", "(", "op", "==", "PLUS_EXPR", "||", "op", "==", "MINUS_EXPR", ")", ";", "muldiv_p", "=", "(", "op", "==", "MULT_EXPR", "||", "op", "==", "RDIV_EXPR", "||", "op", "==", "TRUNC_DIV_EXPR", "||", "op", "==", "CEIL_DIV_EXPR", "||", "op", "==", "FLOOR_DIV_EXPR", "||", "op", "==", "ROUND_DIV_EXPR", ")", ";", "compare_p", "=", "(", "op", "==", "LT_EXPR", "||", "op", "==", "LE_EXPR", "||", "op", "==", "GT_EXPR", "||", "op", "==", "GE_EXPR", "||", "op", "==", "EQ_EXPR", "||", "op", "==", "NE_EXPR", ")", ";", "if", "(", "bool1_p", "&&", "bool2_p", "&&", "(", "plusminus_p", "||", "muldiv_p", ")", ")", "return", "N_", "(", "\"binary operator does not support two vector bool operands\"", ")", ";", "if", "(", "bool1_p", "!=", "bool2_p", "&&", "(", "muldiv_p", "||", "compare_p", ")", ")", "return", "N_", "(", "\"binary operator does not support vector bool operand\"", ")", ";", "mode1", "=", "TYPE_MODE", "(", "type1", ")", ";", "mode2", "=", "TYPE_MODE", "(", "type2", ")", ";", "if", "(", "bool1_p", "!=", "bool2_p", "&&", "plusminus_p", "&&", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_VECTOR_FLOAT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_VECTOR_FLOAT", ")", ")", "return", "N_", "(", "\"binary operator does not support mixing vector \"", "\"bool with floating point vector operands\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "diagnostic", "message", "string", "if", "the", "binary", "operation", "OP", "is", "not", "permitted", "on", "TYPE1", "and", "TYPE2", ",", "NULL", "otherwise", "." ]

[ "s390", "\"types differ in signedness\"", "\"binary operator does not support two vector bool operands\"", "\"binary operator does not support vector bool operand\"", "\"binary operator does not support mixing vector \"", "\"bool with floating point vector operands\"" ]

[]

[ "<s>", "void", "MCS51AsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCS51MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "MCS51", "MCS51", "MCS51" ]

[]

[ "<s>", "void", "ThumbRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "DebugLoc", "&", "dl", ",", "Register", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "Register", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isThumb1Only", "(", ")", ")", "{", "assert", "(", "(", "isARMLowRegister", "(", "DestReg", ")", "||", "DestReg", ".", "isVirtual", "(", ")", ")", "&&", "\"Thumb1 does not have ldr to high register\"", ")", ";", "return", "emitThumb1LoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Val", ",", "Pred", ",", "PredReg", ",", "MIFlags", ")", ";", "}", "return", "emitThumb2LoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "DestReg", ",", "SubIdx", ",", "Val", ",", "Pred", ",", "PredReg", ",", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "ARM", "ARM", "ARM", "\"Thumb1 does not have ldr to high register\"" ]

[]

[ "<s>", "bool", "nds32_expand_strlen", "(", "rtx", "result", ",", "rtx", "str", ",", "rtx", "target_char", ",", "rtx", "align", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "base_reg", ",", "backup_base_reg", ";", "rtx", "ffb_result", ";", "rtx", "target_char_ptr", ",", "length", ";", "rtx", "loop_label", ",", "tmp", ";", "if", "(", "optimize_size", "||", "optimize", "<", "3", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "str", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "target_char", ")", "||", "REG_P", "(", "target_char", ")", ")", ";", "base_reg", "=", "copy_to_mode_reg", "(", "SImode", ",", "XEXP", "(", "str", ",", "0", ")", ")", ";", "loop_label", "=", "gen_label_rtx", "(", ")", ";", "ffb_result", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "backup_base_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "backup_base_reg", ",", "base_reg", ")", ";", "emit_label", "(", "loop_label", ")", ";", "emit_insn", "(", "gen_unaligned_load_update_base_w", "(", "base_reg", ",", "tmp", ",", "base_reg", ")", ")", ";", "emit_insn", "(", "gen_unspec_ffb", "(", "ffb_result", ",", "tmp", ",", "target_char", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "ffb_result", ",", "const0_rtx", ",", "EQ", ",", "NULL", ",", "SImode", ",", "1", ",", "loop_label", ")", ";", "target_char_ptr", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "base_reg", ",", "ffb_result", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "length", "=", "expand_binop", "(", "Pmode", ",", "sub_optab", ",", "target_char_ptr", ",", "backup_base_reg", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "result", ",", "length", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Auxiliary", "function", "for", "expand", "strlen", "pattern", "." ]

[ "nds32", "3", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "diff", ")", "{", "case", "7", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_rev64v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_rev64v8qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "3", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_rev32v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_rev32v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_rev64v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_rev64v4hi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "1", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_rev16v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_rev16v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_rev32v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_rev32v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_rev64v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_rev64v2si", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_rev64v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_rev64v2sf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_rev64v8hf", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_rev64v4hf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "1", ")", "for", "(", "j", "=", "0", ";", "j", "<=", "diff", ";", "j", "+=", "1", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "insns", "." ]

[ "aarch64", "0", "7", "3", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ")", "const", "{", "auto", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "auto", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "if", "(", "!", "DstSubReg", ")", "return", "true", ";", "if", "(", "NewRC", "->", "getSize", "(", ")", "<", "32", "&&", "DstRC", "->", "getSize", "(", ")", "<", "32", "&&", "SrcRC", "->", "getSize", "(", ")", "<", "32", ")", "return", "true", ";", "auto", "NewRCWeight", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegClassWeight", "(", "NewRC", ")", ";", "auto", "SrcRCWeight", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegClassWeight", "(", "SrcRC", ")", ";", "auto", "DstRCWeight", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegClassWeight", "(", "DstRC", ")", ";", "if", "(", "SrcRCWeight", ".", "RegWeight", ">", "NewRCWeight", ".", "RegWeight", ")", "return", "true", ";", "if", "(", "DstRCWeight", ".", "RegWeight", ">", "NewRCWeight", ".", "RegWeight", ")", "return", "true", ";", "auto", "AFI", "=", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "auto", "It", "=", "AFI", "->", "getCoalescedWeight", "(", "MBB", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\tARM::shouldCoalesce - Coalesced Weight: \"", "<<", "It", "->", "second", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\tARM::shouldCoalesce - Reg Weight: \"", "<<", "NewRCWeight", ".", "RegWeight", "<<", "\"\\n\"", ")", ";", "unsigned", "SizeMultiplier", "=", "MBB", "->", "size", "(", ")", "/", "100", ";", "SizeMultiplier", "=", "SizeMultiplier", "?", "SizeMultiplier", ":", "1", ";", "if", "(", "It", "->", "second", "<", "NewRCWeight", ".", "WeightLimit", "*", "SizeMultiplier", ")", "{", "It", "->", "second", "+=", "NewRCWeight", ".", "RegWeight", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "ARM", "ARM", "32", "32", "32", "ARM", "\"\\tARM::shouldCoalesce - Coalesced Weight: \"", "\"\\n\"", "\"\\tARM::shouldCoalesce - Reg Weight: \"", "\"\\n\"", "100", "1" ]

[]

[ "<s>", "SDValue", "KudeyarTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "default", ":", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "ISD::SIGN_EXTEND", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SETCC", "ISD::BR_CC", "ISD::SELECT_CC" ]

[]

[ "<s>", "static", "void", "tilepro_conditional_register_usage", "(", "void", ")", "{", "global_regs", "[", "TILEPRO_NETORDER_REGNUM", "]", "=", "1", ";", "if", "(", "TILEPRO_PIC_TEXT_LABEL_REGNUM", "!=", "INVALID_REGNUM", ")", "{", "fixed_regs", "[", "TILEPRO_PIC_TEXT_LABEL_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "TILEPRO_PIC_TEXT_LABEL_REGNUM", "]", "=", "1", ";", "}", "if", "(", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", ")", "{", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implemnet", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

[ "tilepro", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "I", "->", "isDebugValue", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "STWFI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "XCore", "XCore", "XCore::STWFI", "0" ]

[]

[ "<s>", "static", "void", "def_builtin", "(", "const", "char", "*", "name", ",", "tree", "type", ",", "enum", "rs6000_builtins", "code", ")", "{", "tree", "t", ";", "unsigned", "classify", "=", "rs6000_builtin_info", "[", "(", "int", ")", "code", "]", ".", "attr", ";", "const", "char", "*", "attr_string", "=", "\"\"", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "(", "int", ")", "code", ",", "0", ",", "(", "int", ")", "RS6000_BUILTIN_COUNT", ")", ")", ";", "if", "(", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", ")", "fatal_error", "(", "input_location", ",", "\"internal error: builtin function %qs already processed\"", ",", "name", ")", ";", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", "=", "t", "=", "add_builtin_function", "(", "name", ",", "type", ",", "(", "int", ")", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "if", "(", "(", "classify", "&", "RS6000_BTC_CONST", ")", "!=", "0", ")", "{", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", const\"", ";", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_PURE", ")", "!=", "0", ")", "{", "DECL_PURE_P", "(", "t", ")", "=", "1", ";", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", pure\"", ";", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_FP", ")", "!=", "0", ")", "{", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "if", "(", "flag_rounding_math", ")", "{", "DECL_PURE_P", "(", "t", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", fp, pure\"", ";", "}", "else", "{", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", fp, const\"", ";", "}", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_ATTR_MASK", ")", "!=", "0", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "\"rs6000_builtin, code = %4d, %s%s\\n\"", ",", "(", "int", ")", "code", ",", "name", ",", "attr_string", ")", ";", "}", "</s>" ]

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

[ "rs6000", "\"\"", "0", "\"internal error: builtin function %qs already processed\"", "0", "1", "1", "\", const\"", "0", "1", "1", "\", pure\"", "0", "1", "1", "1", "\", fp, pure\"", "1", "\", fp, const\"", "0", "\"rs6000_builtin, code = %4d, %s%s\\n\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_recurse", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "tree", "f", ";", "for", "(", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "DECL_CHAIN", "(", "f", ")", ")", "if", "(", "TREE_CODE", "(", "f", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "tree", "ftype", "=", "TREE_TYPE", "(", "f", ")", ";", "machine_mode", "mode", ";", "if", "(", "ftype", "==", "error_mark_node", ")", "continue", ";", "mode", "=", "TYPE_MODE", "(", "ftype", ")", ";", "if", "(", "DECL_SIZE", "(", "f", ")", "!=", "0", "&&", "tree_fits_uhwi_p", "(", "bit_position", "(", "f", ")", ")", ")", "bitpos", "+=", "int_bit_position", "(", "f", ")", ";", "if", "(", "TREE_CODE", "(", "ftype", ")", "==", "RECORD_TYPE", ")", "rs6000_darwin64_record_arg_recurse", "(", "cum", ",", "ftype", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "else", "if", "(", "cum", "->", "named", "&&", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ")", ")", "{", "unsigned", "n_fpreg", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", ">>", "3", ";", "switch", "(", "mode", ")", "{", "case", "E_SCmode", ":", "mode", "=", "SFmode", ";", "break", ";", "case", "E_DCmode", ":", "mode", "=", "DFmode", ";", "break", ";", "case", "E_TCmode", ":", "mode", "=", "TFmode", ";", "break", ";", "default", ":", "break", ";", "}", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "if", "(", "cum", "->", "fregno", "+", "n_fpreg", ">", "FP_ARG_MAX_REG", "+", "1", ")", "{", "gcc_assert", "(", "cum", "->", "fregno", "==", "FP_ARG_MAX_REG", "&&", "(", "mode", "==", "TFmode", "||", "mode", "==", "TDmode", ")", ")", ";", "mode", "=", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "?", "DDmode", ":", "DFmode", ";", "cum", "->", "use_stack", "=", "1", ";", "}", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "fregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "if", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "cum", "->", "fregno", "++", ";", "}", "else", "if", "(", "cum", "->", "named", "&&", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "1", ")", ")", "{", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "vregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "}", "else", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "cum", "->", "intoffset", "=", "bitpos", ";", "}", "}", "</s>" ]

[ "Recursive", "workhorse", "for", "the", "following", "." ]

[ "rs6000", "0", "7", "3", "1", "1", "1", "1" ]

[]

[ "<s>", "unsigned", "ARMInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STR", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "FSTD", ":", "case", "ARM", "::", "FSTS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "tSpill", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::STR", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::FSTD", "ARM::FSTS", "1", "2", "2", "0", "1", "0", "ARM::tSpill", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "Instruction", "*", "SPIRVEmitIntrinsics", "::", "visitInsertValueInst", "(", "InsertValueInst", "&", "I", ")", "{", "SmallVector", "<", "Type", "*", ",", "1", ">", "Types", "=", "{", "I", ".", "getInsertedValueOperand", "(", ")", "->", "getType", "(", ")", "}", ";", "SmallVector", "<", "Value", "*", ">", "Args", ";", "for", "(", "auto", "&", "Op", ":", "I", ".", "operands", "(", ")", ")", "if", "(", "isa", "<", "UndefValue", ">", "(", "Op", ")", ")", "Args", ".", "push_back", "(", "UndefValue", "::", "get", "(", "IRB", "->", "getInt32Ty", "(", ")", ")", ")", ";", "else", "Args", ".", "push_back", "(", "Op", ")", ";", "for", "(", "auto", "&", "Op", ":", "I", ".", "indices", "(", ")", ")", "Args", ".", "push_back", "(", "IRB", "->", "getInt32", "(", "Op", ")", ")", ";", "Instruction", "*", "NewI", "=", "IRB", "->", "CreateIntrinsic", "(", "Intrinsic", "::", "spv_insertv", ",", "{", "Types", "}", ",", "{", "Args", "}", ")", ";", "replaceMemInstrUses", "(", "&", "I", ",", "NewI", ")", ";", "return", "NewI", ";", "}", "</s>" ]

[ "Try", "to", "find", "redundant", "insertvalue", "instructions", ",", "like", "the", "following", "ones", ":", "%", "0", "=", "insertvalue", "{", "i8", ",", "i32", "}", "undef", ",", "i8", "x", ",", "0", "%", "1", "=", "insertvalue", "{", "i8", ",", "i32", "}", "%", "0", ",", "i8", "y", ",", "0", "Here", "the", "second", "instruction", "inserts", "values", "at", "the", "same", "indices", ",", "as", "the", "first", "one", ",", "making", "the", "first", "one", "redundant", "." ]

[ "SPIRV", "SPIRV", "1", "Intrinsic::spv_insertv" ]

[]

[ "<s>", "static", "int", "h8300_shift_costs", "(", "rtx", "x", ")", "{", "rtx", "operands", "[", "3", "]", ";", "if", "(", "GET_MODE", "(", "x", ")", "!=", "QImode", "&&", "GET_MODE", "(", "x", ")", "!=", "HImode", "&&", "GET_MODE", "(", "x", ")", "!=", "SImode", ")", "return", "100", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "x", ")", ",", "0", ")", ";", "operands", "[", "1", "]", "=", "NULL", ";", "operands", "[", "2", "]", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "compute_a_shift_length", "(", "operands", ",", "GET_CODE", "(", "x", ")", ")", "/", "2", ";", "}", "</s>" ]

[ "Compute", "the", "cost", "of", "a", "shift", "insn", "." ]

[ "h8300", "3", "100", "0", "0", "1", "2", "1", "2" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastLowerCall", "(", "CallLoweringInfo", "&", "CLI", ")", "{", "CallingConv", "::", "ID", "CC", "=", "CLI", ".", "CallConv", ";", "bool", "IsTailCall", "=", "CLI", ".", "IsTailCall", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "const", "Value", "*", "Callee", "=", "CLI", ".", "Callee", ";", "MCSymbol", "*", "Symbol", "=", "CLI", ".", "Symbol", ";", "if", "(", "CC", "==", "CallingConv", "::", "Fast", ")", "return", "false", ";", "if", "(", "IsTailCall", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "MVT", "RetVT", ";", "if", "(", "CLI", ".", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeSupported", "(", "CLI", ".", "RetTy", ",", "RetVT", ")", ")", "return", "false", ";", "for", "(", "auto", "Flag", ":", "CLI", ".", "OutFlags", ")", "if", "(", "Flag", ".", "isInReg", "(", ")", "||", "Flag", ".", "isSRet", "(", ")", "||", "Flag", ".", "isNest", "(", ")", "||", "Flag", ".", "isByVal", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "MVT", ",", "16", ">", "OutVTs", ";", "OutVTs", ".", "reserve", "(", "CLI", ".", "OutVals", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "*", "Val", ":", "CLI", ".", "OutVals", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "&&", "!", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "64", ")", "return", "false", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "Address", "Addr", ";", "if", "(", "!", "computeCallAddress", "(", "Callee", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "CLI", ",", "OutVTs", ",", "NumBytes", ")", ")", "return", "false", ";", "if", "(", "!", "Addr", ".", "getGlobalValue", "(", ")", ")", "return", "false", ";", "unsigned", "DestAddress", ";", "if", "(", "Symbol", ")", "DestAddress", "=", "materializeExternalCallSym", "(", "Symbol", ")", ";", "else", "DestAddress", "=", "materializeGV", "(", "Addr", ".", "getGlobalValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "emitInst", "(", "TargetOpcode", "::", "COPY", ",", "Mips", "::", "T9", ")", ".", "addReg", "(", "DestAddress", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "JALR", ")", ",", "Mips", "::", "RA", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "*", "FuncInfo", ".", "MF", ",", "CC", ")", ")", ";", "CLI", ".", "Call", "=", "MIB", ";", "return", "finishCall", "(", "CLI", ",", "RetVT", ",", "NumBytes", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "call", "lowering", "." ]

[ "Mips", "Mips", "MVT::isVoid", "16", "MVT::i1", "MVT::i8", "MVT::i16", "64", "MVT::i32", "Mips::T9", "Mips::JALR", "Mips::RA", "Mips::T9" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PowerPC Machine Code Emitter\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"PowerPC Machine Code Emitter\"" ]

[]

[ "<s>", "const", "int", "*", "SIRegisterInfo", "::", "getRegUnitPressureSets", "(", "unsigned", "RegUnit", ")", "const", "{", "static", "const", "int", "Empty", "[", "]", "=", "{", "-", "1", "}", ";", "if", "(", "hasRegUnit", "(", "AMDGPU", "::", "M0", ",", "RegUnit", ")", ")", "return", "Empty", ";", "return", "AMDGPURegisterInfo", "::", "getRegUnitPressureSets", "(", "RegUnit", ")", ";", "}", "</s>" ]

[ "Get", "the", "dimensions", "of", "register", "pressure", "impacted", "by", "this", "register", "unit", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::M0", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "sparc_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "return", "TARGET_VIS", "&&", "VECTOR_MODE_P", "(", "mode", ")", "?", "true", ":", "false", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_VECTOR_MODE_SUPPORTED_P", "target", "hook", ".", "Specify", "whether", "the", "vector", "mode", "is", "supported", "by", "the", "hardware", "." ]

[ "sparc" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "VReg", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "if", "(", "!", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VReg", ")", ";", "}", ")", ")", "return", "false", ";", "OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "8", "X86" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be spilled\"", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "SrcReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "isVectorSuperClass", "(", "RC", ")", "?", "getAVSpillSaveOpcode", "(", "SpillSize", ")", ":", "RI", ".", "isAGPRClass", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be spilled\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]

[ "<s>", "void", "CSKYPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZERO_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSIGN_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSIGN_EXTEND_INREG", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "MERGE_HIGH", ":", "case", "SystemZISD", "::", "MERGE_LOW", ":", "return", "combineMERGE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineSTORE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "combineEXTRACT_VECTOR_ELT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "JOIN_DWORDS", ":", "return", "combineJOIN_DWORDS", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "combineFP_ROUND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BSWAP", ":", "return", "combineBSWAP", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "BR_CCMASK", ":", "return", "combineBR_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "return", "combineSELECT_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "GET_CCMASK", ":", "return", "combineGET_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "return", "combineIntDIVREM", "(", "N", ",", "DCI", ")", ";", "}", "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", "." ]

[ "SystemZ", "SystemZ", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_INREG", "SystemZISD::MERGE_HIGH", "SystemZISD::MERGE_LOW", "ISD::STORE", "ISD::EXTRACT_VECTOR_ELT", "SystemZISD::JOIN_DWORDS", "ISD::FP_ROUND", "ISD::BSWAP", "SystemZISD::BR_CCMASK", "SystemZISD::SELECT_CCMASK", "SystemZISD::GET_CCMASK", "ISD::SDIV", "ISD::UDIV", "ISD::SREM", "ISD::UREM" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "Created", ")", "const", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SDIV", ")", "return", "SDValue", "(", ")", ";", "const", "auto", "&", "ST", "=", "DAG", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "bool", "MinSize", "=", "ST", ".", "hasMinSize", "(", ")", ";", "const", "bool", "HasDivide", "=", "ST", ".", "isThumb", "(", ")", "?", "ST", ".", "hasDivideInThumbMode", "(", ")", ":", "ST", ".", "hasDivideInARMMode", "(", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "isVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "MinSize", "&&", "HasDivide", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "ST", ".", "isThumb", "(", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "if", "(", "Divisor", ".", "sgt", "(", "128", ")", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", "N", ",", "0", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "ARM", "ARM", "ISD::SDIV", "ARM", "ARM", "0", "0", "128", "0" ]

[]

[ "<s>", "static", "void", "tilepro_option_override", "(", "void", ")", "{", "if", "(", "flag_modulo_sched", ")", "flag_resched_modulo_sched", "=", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "tilepro", "1" ]

[]

[ "<s>", "static", "void", "ix86_find_max_used_stack_alignment", "(", "unsigned", "int", "&", "stack_alignment", ",", "bool", "check_stack_slot", ")", "{", "HARD_REG_SET", "set_up_by_prologue", ",", "prologue_used", ";", "basic_block", "bb", ";", "CLEAR_HARD_REG_SET", "(", "prologue_used", ")", ";", "CLEAR_HARD_REG_SET", "(", "set_up_by_prologue", ")", ";", "add_to_hard_reg_set", "(", "&", "set_up_by_prologue", ",", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "add_to_hard_reg_set", "(", "&", "set_up_by_prologue", ",", "Pmode", ",", "ARG_POINTER_REGNUM", ")", ";", "add_to_hard_reg_set", "(", "&", "set_up_by_prologue", ",", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "stack_alignment", ">", "crtl", "->", "preferred_stack_boundary", ")", "stack_alignment", "=", "crtl", "->", "preferred_stack_boundary", ";", "bool", "require_stack_frame", "=", "false", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", "&&", "requires_stack_frame_p", "(", "insn", ",", "prologue_used", ",", "set_up_by_prologue", ")", ")", "{", "require_stack_frame", "=", "true", ";", "if", "(", "check_stack_slot", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", "&&", "(", "reg_mentioned_p", "(", "stack_pointer_rtx", ",", "*", "iter", ")", "||", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "*", "iter", ")", ")", ")", "{", "unsigned", "int", "alignment", "=", "MEM_ALIGN", "(", "*", "iter", ")", ";", "if", "(", "alignment", ">", "stack_alignment", ")", "stack_alignment", "=", "alignment", ";", "}", "}", "}", "}", "cfun", "->", "machine", "->", "stack_frame_required", "=", "require_stack_frame", ";", "}", "</s>" ]

[ "Return", "true", "if", "stack", "frame", "is", "required", ".", "Update", "STACK_ALIGNMENT", "to", "the", "largest", "alignment", ",", "in", "bits", ",", "of", "stack", "slot", "used", "if", "stack", "frame", "is", "required", "and", "CHECK_STACK_SLOT", "is", "true", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "i386_pe_valid_dllimport_attribute_p", "(", "tree", "decl", ")", "{", "if", "(", "TARGET_NOP_FUN_DLLIMPORT", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Handle", "the", "-mno-fun-dllimport", "target", "switch", "." ]

[ "i386" ]

[]

[ "<s>", "void", "sh_split_tst_subregs", "(", "rtx_insn", "*", "curr_insn", ",", "machine_mode", "subreg_mode", ",", "int", "subreg_offset", ",", "rtx", "operands", "[", "]", ")", "{", "gcc_assert", "(", "subreg_mode", "==", "QImode", "||", "subreg_mode", "==", "HImode", ")", ";", "sh_extending_set_of_reg", "eop0", "=", "sh_find_extending_set_of_reg", "(", "operands", "[", "0", "]", ",", "curr_insn", ")", ";", "sh_extending_set_of_reg", "eop1", "=", "sh_find_extending_set_of_reg", "(", "operands", "[", "1", "]", ",", "curr_insn", ")", ";", "if", "(", "eop0", ".", "ext_code", "==", "ZERO_EXTEND", "&&", "eop0", ".", "from_mode", "==", "subreg_mode", ")", "{", "emit_insn", "(", "gen_tstsi_t", "(", "eop0", ".", "use_as_extended_reg", "(", "curr_insn", ")", ",", "operands", "[", "1", "]", ")", ")", ";", "return", ";", "}", "if", "(", "eop1", ".", "ext_code", "==", "ZERO_EXTEND", "&&", "eop1", ".", "from_mode", "==", "subreg_mode", ")", "{", "emit_insn", "(", "gen_tstsi_t", "(", "operands", "[", "0", "]", ",", "eop1", ".", "use_as_extended_reg", "(", "curr_insn", ")", ")", ")", ";", "return", ";", "}", "if", "(", "eop0", ".", "ext_code", "==", "SIGN_EXTEND", "&&", "eop1", ".", "ext_code", "==", "SIGN_EXTEND", "&&", "eop0", ".", "from_mode", "==", "subreg_mode", "&&", "eop1", ".", "from_mode", "==", "subreg_mode", ")", "{", "emit_insn", "(", "gen_tstsi_t", "(", "eop0", ".", "use_as_extended_reg", "(", "curr_insn", ")", ",", "eop1", ".", "use_as_extended_reg", "(", "curr_insn", ")", ")", ")", ";", "return", ";", "}", "if", "(", "eop0", ".", "ext_code", "!=", "UNKNOWN", "&&", "eop1", ".", "ext_code", "==", "UNKNOWN", ")", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "rtx", "tmp0", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp1", "=", "simplify_gen_subreg", "(", "subreg_mode", ",", "operands", "[", "0", "]", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "subreg_offset", ")", ";", "emit_insn", "(", "subreg_mode", "==", "QImode", "?", "gen_zero_extendqisi2", "(", "tmp0", ",", "tmp1", ")", ":", "gen_zero_extendhisi2", "(", "tmp0", ",", "tmp1", ")", ")", ";", "emit_insn", "(", "gen_tstsi_t", "(", "tmp0", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Given", "the", "current", "insn", ",", "which", "is", "assumed", "to", "be", "the", "*", "tst", "<", "mode", ">", "_t_subregs", "insn", ",", "perform", "the", "necessary", "checks", "on", "the", "operands", "and", "split", "it", "accordingly", "." ]

[ "sh", "0", "1", "1", "0", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "rtx", "microblaze_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "ret", ";", "int", "regbase", "=", "-", "1", ";", "int", "*", "arg_words", "=", "&", "cum", "->", "arg_words", ";", "cum", "->", "last_arg_fp", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "DFmode", ":", "case", "VOIDmode", ":", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "regbase", "=", "GP_ARG_FIRST", ";", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "case", "BLKmode", ":", "regbase", "=", "GP_ARG_FIRST", ";", "break", ";", "}", "if", "(", "*", "arg_words", ">=", "MAX_ARGS_IN_REGISTERS", ")", "ret", "=", "0", ";", "else", "{", "gcc_assert", "(", "regbase", "!=", "-", "1", ")", ";", "ret", "=", "gen_rtx_REG", "(", "mode", ",", "regbase", "+", "*", "arg_words", ")", ";", "}", "if", "(", "mode", "==", "VOIDmode", ")", "{", "if", "(", "cum", "->", "num_adjusts", ">", "0", ")", "ret", "=", "gen_rtx_PARALLEL", "(", "(", "machine_mode", ")", "cum", "->", "fp_code", ",", "gen_rtvec_v", "(", "cum", "->", "num_adjusts", ",", "cum", "->", "adjust", ")", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", "." ]

[ "microblaze", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "tree", "ix86_valid_target_attribute_tree", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "const", "char", "*", "orig_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "const", "char", "*", "orig_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "enum", "fpmath_unit", "orig_fpmath_set", "=", "opts_set", "->", "x_ix86_fpmath", ";", "int", "orig_tune_defaulted", "=", "ix86_tune_defaulted", ";", "int", "orig_arch_specified", "=", "ix86_arch_specified", ";", "char", "*", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_MAX", "]", "=", "{", "NULL", ",", "NULL", "}", ";", "tree", "t", "=", "NULL_TREE", ";", "int", "i", ";", "struct", "cl_target_option", "*", "def", "=", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ";", "struct", "gcc_options", "enum_opts_set", ";", "memset", "(", "&", "enum_opts_set", ",", "0", ",", "sizeof", "(", "enum_opts_set", ")", ")", ";", "if", "(", "!", "ix86_valid_target_attribute_inner_p", "(", "args", ",", "option_strings", ",", "opts", ",", "opts_set", ",", "&", "enum_opts_set", ")", ")", "return", "error_mark_node", ";", "if", "(", "opts", "->", "x_ix86_isa_flags", "!=", "def", "->", "x_ix86_isa_flags", "||", "opts", "->", "x_target_flags", "!=", "def", "->", "x_target_flags", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", "||", "enum_opts_set", ".", "x_ix86_fpmath", ")", "{", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", "{", "opts", "->", "x_ix86_arch_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", ";", "opts", "->", "x_ix86_isa_flags", "&=", "(", "OPTION_MASK_ISA_64BIT", "|", "OPTION_MASK_ABI_64", "|", "OPTION_MASK_ABI_X32", "|", "OPTION_MASK_CODE16", ")", ";", "}", "else", "if", "(", "!", "orig_arch_specified", ")", "opts", "->", "x_ix86_arch_string", "=", "NULL", ";", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", "opts", "->", "x_ix86_tune_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", ";", "else", "if", "(", "orig_tune_defaulted", ")", "opts", "->", "x_ix86_tune_string", "=", "NULL", ";", "if", "(", "enum_opts_set", ".", "x_ix86_fpmath", ")", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "else", "if", "(", "!", "TARGET_64BIT_P", "(", "opts", "->", "x_ix86_isa_flags", ")", "&&", "TARGET_SSE_P", "(", "opts", "->", "x_ix86_isa_flags", ")", ")", "{", "if", "(", "TARGET_80387_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "(", "FPMATH_SSE", "|", "FPMATH_387", ")", ";", "else", "opts", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "FPMATH_SSE", ";", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "}", "ix86_option_override_internal", "(", "false", ",", "opts", ",", "opts_set", ")", ";", "ix86_add_new_builtins", "(", "opts", "->", "x_ix86_isa_flags", ")", ";", "t", "=", "build_target_option_node", "(", "opts", ")", ";", "opts", "->", "x_ix86_arch_string", "=", "orig_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "orig_tune_string", ";", "opts_set", "->", "x_ix86_fpmath", "=", "orig_fpmath_set", ";", "for", "(", "i", "=", "0", ";", "i", "<", "IX86_FUNCTION_SPECIFIC_MAX", ";", "i", "++", ")", "free", "(", "option_strings", "[", "i", "]", ")", ";", "}", "return", "t", ";", "}", "</s>" ]

[ "Return", "a", "TARGET_OPTION_NODE", "tree", "of", "the", "target", "options", "listed", "or", "NULL", "." ]

[ "i386", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "pad_bb", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next_insn", ",", "*", "prev_insn", ",", "*", "hbr_insn", "=", "0", ";", "int", "length", ";", "int", "addr", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "length", "=", "0", ";", "prev_insn", "=", "0", ";", "insn", "=", "get_insns", "(", ")", ";", "if", "(", "!", "active_insn_p", "(", "insn", ")", ")", "insn", "=", "next_active_insn", "(", "insn", ")", ";", "for", "(", ";", "insn", ";", "insn", "=", "next_insn", ")", "{", "next_insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_hbr", ")", "{", "if", "(", "hbr_insn", ")", "{", "int", "a0", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "hbr_insn", ")", ")", ";", "int", "a1", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "(", "a1", "-", "a0", "==", "8", "&&", "GET_MODE", "(", "insn", ")", "!=", "TImode", ")", "||", "(", "a1", "-", "a0", "==", "4", ")", ")", "{", "prev_insn", "=", "emit_insn_before", "(", "gen_lnop", "(", ")", ",", "insn", ")", ";", "PUT_MODE", "(", "prev_insn", ",", "GET_MODE", "(", "insn", ")", ")", ";", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "INSN_LOCATION", "(", "prev_insn", ")", "=", "INSN_LOCATION", "(", "insn", ")", ";", "length", "+=", "4", ";", "}", "}", "hbr_insn", "=", "insn", ";", "}", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_blockage", "&&", "next_insn", ")", "{", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "PUT_MODE", "(", "next_insn", ",", "TImode", ")", ";", "insn", "=", "next_insn", ";", "next_insn", "=", "next_active_insn", "(", "insn", ")", ";", "}", "addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "(", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", ")", "&&", "SCHED_ON_EVEN_P", "(", "insn", ")", ")", "{", "if", "(", "(", "(", "addr", "+", "length", ")", "&", "7", ")", "!=", "0", ")", "{", "emit_nop_for_insn", "(", "prev_insn", ")", ";", "length", "+=", "4", ";", "}", "}", "else", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", "&&", "(", "(", "next_insn", "&&", "GET_MODE", "(", "next_insn", ")", "!=", "TImode", ")", "||", "get_attr_type", "(", "insn", ")", "==", "TYPE_MULTI0", ")", "&&", "(", "(", "addr", "+", "length", ")", "&", "7", ")", "!=", "0", ")", "{", "emit_nop_for_insn", "(", "prev_insn", ")", ";", "length", "+=", "4", ";", "}", "prev_insn", "=", "insn", ";", "}", "}", "</s>" ]

[ "Insert", "nops", "in", "basic", "blocks", "to", "meet", "dual", "issue", "alignment", "requirements", ".", "Also", "make", "sure", "hbrp", "and", "hint", "instructions", "are", "at", "least", "one", "cycle", "apart", ",", "possibly", "inserting", "a", "nop", "." ]

[ "spu", "0", "0", "0", "8", "4", "4", "7", "0", "4", "7", "0", "4" ]

[]

[ "<s>", "void", "aarch64_override_options_internal", "(", "struct", "gcc_options", "*", "opts", ")", "{", "aarch64_tune_flags", "=", "selected_tune", "->", "flags", ";", "aarch64_tune", "=", "selected_tune", "->", "sched_core", ";", "aarch64_tune_params", "=", "*", "(", "selected_tune", "->", "tune", ")", ";", "aarch64_architecture_version", "=", "selected_arch", "->", "architecture_version", ";", "if", "(", "opts", "->", "x_aarch64_override_tune_string", ")", "aarch64_parse_override_string", "(", "opts", "->", "x_aarch64_override_tune_string", ",", "&", "aarch64_tune_params", ")", ";", "if", "(", "opts", "->", "x_flag_strict_volatile_bitfields", "<", "0", "&&", "abi_version_at_least", "(", "2", ")", ")", "opts", "->", "x_flag_strict_volatile_bitfields", "=", "1", ";", "initialize_aarch64_code_model", "(", "opts", ")", ";", "initialize_aarch64_tls_size", "(", "opts", ")", ";", "int", "queue_depth", "=", "0", ";", "switch", "(", "aarch64_tune_params", ".", "autoprefetcher_model", ")", "{", "case", "tune_params", "::", "AUTOPREFETCHER_OFF", ":", "queue_depth", "=", "-", "1", ";", "break", ";", "case", "tune_params", "::", "AUTOPREFETCHER_WEAK", ":", "queue_depth", "=", "0", ";", "break", ";", "case", "tune_params", "::", "AUTOPREFETCHER_STRONG", ":", "queue_depth", "=", "max_insn_queue_index", "+", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "maybe_set_param_value", "(", "PARAM_SCHED_AUTOPREF_QUEUE_DEPTH", ",", "queue_depth", ",", "opts", "->", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "if", "(", "selected_cpu", "->", "tune", "->", "cache_line_size", "!=", "0", ")", "maybe_set_param_value", "(", "PARAM_L1_CACHE_LINE_SIZE", ",", "selected_cpu", "->", "tune", "->", "cache_line_size", ",", "opts", "->", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "aarch64_override_options_after_change_1", "(", "opts", ")", ";", "}", "</s>" ]

[ "'Unpack", "'", "up", "the", "internal", "tuning", "structs", "and", "update", "the", "options", "in", "OPTS", ".", "The", "caller", "must", "have", "set", "up", "selected_tune", "and", "selected_arch", "as", "all", "the", "other", "target-specific", "codegen", "decisions", "are", "derived", "from", "them", "." ]

[ "aarch64", "0", "2", "1", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "MachineInstr", "*", "HexagonInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FI", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "MachineInstrBuilder", "MipsInstrInfo", "::", "genInstrWithNewOpc", "(", "unsigned", "NewOpc", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "int", "ZeroOperandPosition", "=", "-", "1", ";", "bool", "BranchWithZeroOperand", "=", "false", ";", "if", "(", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isPseudo", "(", ")", ")", "{", "auto", "TRI", "=", "I", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "ZeroOperandPosition", "=", "I", "->", "findRegisterUseOperandIdx", "(", "Mips", "::", "ZERO", ",", "false", ",", "TRI", ")", ";", "BranchWithZeroOperand", "=", "ZeroOperandPosition", "!=", "-", "1", ";", "}", "if", "(", "BranchWithZeroOperand", ")", "{", "switch", "(", "NewOpc", ")", "{", "case", "Mips", "::", "BEQC", ":", "NewOpc", "=", "Mips", "::", "BEQZC", ";", "break", ";", "case", "Mips", "::", "BNEC", ":", "NewOpc", "=", "Mips", "::", "BNEZC", ";", "break", ";", "case", "Mips", "::", "BGEC", ":", "NewOpc", "=", "Mips", "::", "BGEZC", ";", "break", ";", "case", "Mips", "::", "BLTC", ":", "NewOpc", "=", "Mips", "::", "BLTZC", ";", "break", ";", "case", "Mips", "::", "BEQC64", ":", "NewOpc", "=", "Mips", "::", "BEQZC64", ";", "break", ";", "case", "Mips", "::", "BNEC64", ":", "NewOpc", "=", "Mips", "::", "BNEZC64", ";", "break", ";", "}", "}", "MIB", "=", "BuildMI", "(", "*", "I", "->", "getParent", "(", ")", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpc", ")", ")", ";", "if", "(", "NewOpc", "==", "Mips", "::", "JIC", "||", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIC64", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "{", "if", "(", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "MIB", "->", "RemoveOperand", "(", "0", ")", ";", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "MIB", ".", "add", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "MIB", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "if", "(", "BranchWithZeroOperand", "&&", "(", "unsigned", ")", "ZeroOperandPosition", "==", "J", ")", "continue", ";", "MIB", ".", "add", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "}", "MIB", ".", "copyImplicitOps", "(", "*", "I", ")", ";", "MIB", ".", "setMemRefs", "(", "I", "->", "memoperands_begin", "(", ")", ",", "I", "->", "memoperands_end", "(", ")", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "Create", "an", "instruction", "which", "has", "the", "same", "operands", "and", "memory", "operands", "as", "MI", "but", "has", "a", "new", "opcode", "." ]

[ "Mips", "Mips", "1", "Mips::ZERO", "1", "Mips::BEQC", "Mips::BEQZC", "Mips::BNEC", "Mips::BNEZC", "Mips::BGEC", "Mips::BGEZC", "Mips::BLTC", "Mips::BLTZC", "Mips::BEQC64", "Mips::BEQZC64", "Mips::BNEC64", "Mips::BNEZC64", "Mips::JIC", "Mips::JIALC", "Mips::JIC64", "Mips::JIALC64", "Mips::JIALC", "Mips::JIALC64", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "LanaiAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IdLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SMLoc", "ErrorLoc", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "case", "Match_Success", ":", "Out", ".", "EmitInstruction", "(", "Inst", ",", "SubtargetInfo", ")", ";", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IdLoc", ",", "\"Instruction use requires option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IdLoc", ",", "\"Unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "ErrorLoc", "=", "IdLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IdLoc", ",", "\"Too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "LanaiOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IdLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"Invalid operand for instruction\"", ")", ";", "}", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"Unknown match type detected!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Lanai", "Lanai", "\"Instruction use requires option to be enabled\"", "\"Unrecognized instruction mnemonic\"", "0U", "\"Too few operands for instruction\"", "Lanai", "\"Invalid operand for instruction\"", "\"Unknown match type detected!\"" ]

[]