Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "MachineInstr", "*", "PPCInstrInfo", "::", "findLoopInstr", "(", "MachineBasicBlock", "&", "PreHeader", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "&", "Visited", ")", "const", "{", "unsigned", "LOOPi", "=", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "MTCTR8loop", ":", "PPC", "::", "MTCTRloop", ")", ";", "for", "(", "auto", "&", "I", ":", "PreHeader", ".", "instrs", "(", ")", ")", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "LOOPi", ")", "return", "&", "I", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Find", "the", "hardware", "loop", "instruction", "used", "to", "set-up", "the", "specified", "loop", "." ]

[ "PowerPC", "PPC", "8", "PPC", "PPC::MTCTR8loop", "PPC::MTCTRloop" ]

[]

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

[ "Return", "the", "register", "class", "ID", "number", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "Note", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "ArrayRef", "<", "SMRange", ">", "Ranges", "=", "None", ")", "{", "return", "Parser", ".", "Note", "(", "L", ",", "Msg", ",", "Ranges", ")", ";", "}", "</s>" ]

[ "Emit", "a", "note", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "LastMI", "=", "MI", ";", "FpMLxStalls", "=", "0", ";", "}", "ScoreboardHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

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

[]

[ "<s>", "static", "int", "rs6000_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "(", "0", ",", "mode", ")", ";", "else", "if", "(", "(", "reg_classes_intersect_p", "(", "rclass", ",", "FLOAT_REGS", ")", "||", "reg_classes_intersect_p", "(", "rclass", ",", "VSX_REGS", ")", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "(", "32", ",", "mode", ")", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "ALTIVEC_REGS", ")", ")", "ret", "=", "4", "*", "hard_regno_nregs", "(", "FIRST_ALTIVEC_REGNO", ",", "mode", ")", ";", "else", "ret", "=", "4", "+", "rs6000_register_move_cost", "(", "mode", ",", "rclass", ",", "GENERAL_REGS", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "rclass", "]", ",", "in", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expressions", "returning", "the", "cost", "of", "moving", "data", "of", "MODE", "from", "a", "register", "to", "or", "from", "memory", "." ]

[ "powerpcspe", "4", "0", "4", "32", "4", "4", "1", "\"rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\\n\"" ]

[]

[ "<s>", "Optional", "<", "ExtAddrMode", ">", "AArch64InstrInfo", "::", "getAddrModeFromMemoryOp", "(", "const", "MachineInstr", "&", "MemI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineOperand", "*", "Base", ";", "int64_t", "Offset", ";", "bool", "OffsetIsScalable", ";", "if", "(", "!", "getMemOperandWithOffset", "(", "MemI", ",", "Base", ",", "Offset", ",", "OffsetIsScalable", ",", "TRI", ")", ")", "return", "None", ";", "if", "(", "!", "Base", "->", "isReg", "(", ")", ")", "return", "None", ";", "ExtAddrMode", "AM", ";", "AM", ".", "BaseReg", "=", "Base", "->", "getReg", "(", ")", ";", "AM", ".", "Displacement", "=", "Offset", ";", "AM", ".", "ScaledReg", "=", "0", ";", "AM", ".", "Scale", "=", "0", ";", "return", "AM", ";", "}", "</s>" ]

[ "Target", "dependent", "implementation", "to", "get", "the", "values", "constituting", "the", "address", "MachineInstr", "that", "is", "accessing", "memory", "." ]

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SparcTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "SP", "::", "IntRegsRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "0", "0U", "SP::IntRegsRegisterClass" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "Register", "DstReg", ",", "Register", "TrueReg", ",", "Register", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "Cond", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "if", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", "||", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "GPRC_NOR0RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RC_NOX0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "false", ";", "CondCycles", "=", "1", ";", "TrueCycles", "=", "1", ";", "FalseCycles", "=", "1", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "PowerPC", "PPC", "2", "1", "PPC::CTR", "1", "PPC::CTR8", "PPC::GPRCRegClass", "PPC::GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_NOX0RegClass", "1", "1", "1" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", "++", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "while", "(", "(", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

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

[]

[ "<s>", "static", "int", "arm_get_set_operands", "(", "rtx", "producer", ",", "rtx", "consumer", ",", "rtx", "*", "set_source", ",", "rtx", "*", "set_destination", ")", "{", "rtx", "set_producer", "=", "arm_find_sub_rtx_with_code", "(", "PATTERN", "(", "producer", ")", ",", "SET", ",", "false", ")", ";", "rtx", "set_consumer", "=", "arm_find_sub_rtx_with_code", "(", "PATTERN", "(", "consumer", ")", ",", "SET", ",", "false", ")", ";", "if", "(", "set_producer", "&&", "set_consumer", ")", "{", "*", "set_source", "=", "SET_DEST", "(", "set_producer", ")", ";", "*", "set_destination", "=", "SET_SRC", "(", "set_consumer", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "PRODUCER", "and", "CONSUMER", "are", "two", "potentially", "dependant", "RTX", ".", "PRODUCER", "(", "possibly", ")", "contains", "a", "SET", "which", "will", "provide", "a", "result", "we", "can", "access", "using", "the", "SET_DEST", "macro", ".", "We", "will", "place", "the", "RTX", "which", "would", "be", "written", "by", "PRODUCER", "in", "SET_SOURCE", ".", "Similarly", ",", "CONSUMER", "(", "possibly", ")", "contains", "a", "SET", "which", "has", "an", "operand", "we", "can", "access", "using", "SET_SRC", ".", "We", "place", "this", "operand", "in", "SET_DESTINATION", ".", "Return", "nonzero", "if", "we", "found", "the", "SET", "RTX", "we", "expected", "." ]

[ "arm", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createAMDGPUStructurizeCFGPass", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "R600", "SI" ]

[]

[ "<s>", "bool", "AArch64CondBrTuning", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Branch Tuning **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "LocalChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "CBZW", ":", "case", "AArch64", "::", "CBZX", ":", "case", "AArch64", "::", "CBNZW", ":", "case", "AArch64", "::", "CBNZX", ":", "case", "AArch64", "::", "TBZW", ":", "case", "AArch64", "::", "TBZX", ":", "case", "AArch64", "::", "TBNZW", ":", "case", "AArch64", "::", "TBNZX", ":", "MachineInstr", "*", "DefMI", "=", "getOperandDef", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "LocalChange", "=", "(", "DefMI", "&&", "tryToTuneBranch", "(", "MI", ",", "*", "DefMI", ")", ")", ";", "break", ";", "}", "if", "(", "LocalChange", ")", "{", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Branch Tuning **********\\n\"", "\"********** Function: \"", "AArch64", "AArch64::CBZW", "AArch64::CBZX", "AArch64::CBNZW", "AArch64::CBNZX", "AArch64::TBZW", "AArch64::TBZX", "AArch64::TBNZW", "AArch64::TBNZX", "0" ]

[]

[ "<s>", "bool", "HexagonCommonGEP", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "for", "(", "Function", "::", "iterator", "A", "=", "F", ".", "begin", "(", ")", ",", "Z", "=", "F", ".", "end", "(", ")", ";", "A", "!=", "Z", ";", "++", "A", ")", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "A", "->", "begin", "(", ")", ",", "E", "=", "A", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "isa", "<", "InvokeInst", ">", "(", "I", ")", "||", "isa", "<", "LandingPadInst", ">", "(", "I", ")", ")", "return", "false", ";", "Fn", "=", "&", "F", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ".", "getPostDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "Ctx", "=", "&", "F", ".", "getContext", "(", ")", ";", "Nodes", ".", "clear", "(", ")", ";", "Uses", ".", "clear", "(", ")", ";", "NodeOrder", ".", "clear", "(", ")", ";", "SpecificBumpPtrAllocator", "<", "GepNode", ">", "Allocator", ";", "Mem", "=", "&", "Allocator", ";", "collect", "(", ")", ";", "common", "(", ")", ";", "NodeToValueMap", "Loc", ";", "computeNodePlacement", "(", "Loc", ")", ";", "materialize", "(", "Loc", ")", ";", "removeDeadCode", "(", ")", ";", "verifyFunction", "(", "F", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "tree", "aarch64_add_attribute", "(", "const", "char", "*", "name", ",", "tree", "attrs", ")", "{", "return", "tree_cons", "(", "get_identifier", "(", "name", ")", ",", "NULL_TREE", ",", "attrs", ")", ";", "}", "</s>" ]

[ "Add", "attribute", "NAME", "to", "ATTRS", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "riscv_legitimize_const_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "splittable_const_int_operand", "(", "src", ",", "mode", ")", ")", "{", "riscv_move_integer", "(", "dest", ",", "dest", ",", "INTVAL", "(", "src", ")", ",", "mode", ",", "FALSE", ")", ";", "return", ";", "}", "if", "(", "riscv_split_symbol", "(", "dest", ",", "src", ",", "MAX_MACHINE_MODE", ",", "&", "src", ",", "FALSE", ")", ")", "{", "riscv_emit_set", "(", "dest", ",", "src", ")", ";", "return", ";", "}", "if", "(", "riscv_tls_symbol_p", "(", "src", ")", ")", "{", "riscv_emit_move", "(", "dest", ",", "riscv_legitimize_tls_address", "(", "src", ")", ")", ";", "return", ";", "}", "split_const", "(", "src", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "const0_rtx", "&&", "(", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "src", ")", "||", "can_create_pseudo_p", "(", ")", ")", ")", "{", "base", "=", "riscv_force_temporary", "(", "dest", ",", "base", ",", "FALSE", ")", ";", "riscv_emit_move", "(", "dest", ",", "riscv_add_offset", "(", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ")", ";", "return", ";", "}", "src", "=", "force_const_mem", "(", "mode", ",", "src", ")", ";", "riscv_split_symbol", "(", "dest", ",", "XEXP", "(", "src", ",", "0", ")", ",", "mode", ",", "&", "XEXP", "(", "src", ",", "0", ")", ",", "FALSE", ")", ";", "riscv_emit_move", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "riscv_legitimize_move", ".", "Move", "constant", "SRC", "into", "register", "DEST", "given", "that", "SRC", "satisfies", "immediate_operand", "but", "does", "n't", "satisfy", "move_operand", "." ]

[ "riscv", "0", "0" ]

[]

[ "<s>", "static", "rtx", "cr16_function_value", "(", "const_tree", "type", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "type", ")", ",", "cr16_ret_register", "(", ")", ")", ";", "}", "</s>" ]

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

[ "cr16" ]

[]

[ "<s>", "static", "void", "mmix_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "if", "(", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "(", "DECL_EXTERNAL", "(", "decl", ")", "||", "TREE_PUBLIC", "(", "decl", ")", ")", ")", "||", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "TREE_PUBLIC", "(", "decl", ")", ")", ")", ";", "else", "if", "(", "first", "&&", "DECL_P", "(", "decl", ")", ")", "{", "const", "char", "*", "str", "=", "XSTR", "(", "XEXP", "(", "rtl", ",", "0", ")", ",", "0", ")", ";", "int", "len", "=", "strlen", "(", "str", ")", ";", "char", "*", "newstr", "=", "XALLOCAVEC", "(", "char", ",", "len", "+", "2", ")", ";", "newstr", "[", "0", "]", "=", "'@'", ";", "strcpy", "(", "newstr", "+", "1", ",", "str", ")", ";", "XSTR", "(", "XEXP", "(", "rtl", ",", "0", ")", ",", "0", ")", "=", "ggc_alloc_string", "(", "newstr", ",", "len", "+", "1", ")", ";", "}", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "||", "TREE_CONSTANT", "(", "decl", ")", "||", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "(", "!", "DECL_INITIAL", "(", "decl", ")", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", ")", "SYMBOL_REF_FLAG", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "=", "1", ";", "}", "</s>" ]

[ "ENCODE_SECTION_INFO", "." ]

[ "mmix", "0", "0", "2", "0", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "NyuziAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SMLoc", "ErrorLoc", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "std", "::", "string", ">", ",", "4", ">", "MapAndConstraints", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "ProcessInstruction", "(", "Inst", ",", "IDLoc", ",", "Out", ")", ")", "return", "true", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "NyuziMnemonicSpellCheck", "(", "(", "(", "NyuziOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ")", ";", "}", "case", "Match_InvalidOperand", ":", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "NyuziOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "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", "." ]

[ "Nyuzi", "Nyuzi", "4", "\"instruction use requires option to be enabled\"", "Nyuzi", "Nyuzi", "0", "\"invalid instruction\"", "0U", "\"too few operands for instruction\"", "Nyuzi", "\"invalid operand for instruction\"", "\"Unknown match type detected!\"" ]

[]

[ "<s>", "static", "bool", "mips_expand_vpc_loongson_even_odd", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "odd", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "t0", ",", "t1", ",", "t2", ",", "t3", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ")", "return", "false", ";", "if", "(", "nelt", "<", "4", ")", "return", "false", ";", "odd", "=", "d", "->", "perm", "[", "0", "]", ";", "if", "(", "odd", ">", "1", ")", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "i", "*", "2", "+", "odd", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "t0", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "t1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V4HImode", ":", "emit_insn", "(", "gen_loongson_punpckhhw", "(", "t0", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpcklhw", "(", "t1", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "if", "(", "odd", ")", "emit_insn", "(", "gen_loongson_punpckhhw", "(", "d", "->", "target", ",", "t1", ",", "t0", ")", ")", ";", "else", "emit_insn", "(", "gen_loongson_punpcklhw", "(", "d", "->", "target", ",", "t1", ",", "t0", ")", ")", ";", "break", ";", "case", "E_V8QImode", ":", "t2", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "t3", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "t0", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "t1", ",", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "t2", ",", "t1", ",", "t0", ")", ")", ";", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "t3", ",", "t1", ",", "t0", ")", ")", ";", "if", "(", "odd", ")", "emit_insn", "(", "gen_loongson_punpckhbh", "(", "d", "->", "target", ",", "t3", ",", "t2", ")", ")", ";", "else", "emit_insn", "(", "gen_loongson_punpcklbh", "(", "d", "->", "target", ",", "t3", ",", "t2", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "even-odd", "extraction", "." ]

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

[]

[ "<s>", "void", "gcn_goacc_reduction", "(", "gcall", "*", "call", ")", "{", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "if", "(", "level", "==", "GOMP_DIM_VECTOR", ")", "{", "default_goacc_reduction", "(", "call", ")", ";", "return", ";", "}", "unsigned", "code", "=", "(", "unsigned", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "0", ")", ")", ";", "switch", "(", "code", ")", "{", "case", "IFN_GOACC_REDUCTION_SETUP", ":", "gcn_goacc_reduction_setup", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_INIT", ":", "gcn_goacc_reduction_init", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_FINI", ":", "gcn_goacc_reduction_fini", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_TEARDOWN", ":", "gcn_goacc_reduction_teardown", "(", "call", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_GOACC_REDUCTION", ".", "Expand", "calls", "to", "the", "GOACC", "REDUCTION", "internal", "function", ",", "into", "a", "sequence", "of", "gimple", "instructions", "." ]

[ "gcn", "3", "0" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "UsedList", "=", "AMDGPU", "::", "getUsedList", "(", "M", ")", ";", "bool", "Changed", "=", "processUsedLDS", "(", "M", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "!", "AMDGPU", "::", "isKernelCC", "(", "&", "F", ")", ")", "continue", ";", "Changed", "|=", "processUsedLDS", "(", "M", ",", "&", "F", ")", ";", "}", "UsedList", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU::getUsedList", "AMDGPU::isKernelCC" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "useStackGuardXorFP", "(", ")", "const", "{", "return", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSMSVCRT", "(", ")", "&&", "!", "Subtarget", ".", "isTargetMachO", "(", ")", ";", "}", "</s>" ]

[ "If", "this", "function", "returns", "true", ",", "stack", "protection", "checks", "should", "XOR", "the", "frame", "pointer", "(", "or", "whichever", "pointer", "is", "used", "to", "address", "locals", ")", "into", "the", "stack", "guard", "value", "before", "checking", "it", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "tilepro_fixup_pcrel_references", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next_insn", ";", "bool", "same_section_as_entry", "=", "true", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next_insn", ")", "{", "next_insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_SWITCH_TEXT_SECTIONS", ")", "{", "same_section_as_entry", "=", "!", "same_section_as_entry", ";", "continue", ";", "}", "if", "(", "same_section_as_entry", ")", "continue", ";", "if", "(", "!", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", ")", ")", "continue", ";", "if", "(", "match_addli_pcrel", "(", "insn", ")", ")", "replace_addli_pcrel", "(", "insn", ")", ";", "else", "if", "(", "match_auli_pcrel", "(", "insn", ")", ")", "replace_auli_pcrel", "(", "insn", ")", ";", "}", "}", "</s>" ]

[ "We", "generate", "PC", "relative", "SYMBOL_REFs", "as", "an", "optimization", ",", "to", "avoid", "going", "through", "the", "GOT", "when", "the", "symbol", "is", "local", "to", "the", "compilation", "unit", ".", "But", "such", "a", "symbol", "requires", "that", "the", "common", "text_label", "that", "we", "generate", "at", "the", "beginning", "of", "the", "function", "be", "in", "the", "same", "section", "as", "the", "reference", "to", "the", "SYMBOL_REF", ".", "This", "may", "not", "be", "true", "if", "we", "generate", "hot/cold", "sections", ".", "This", "function", "looks", "for", "such", "cases", "and", "replaces", "such", "references", "with", "the", "longer", "sequence", "going", "through", "the", "GOT", ".", "We", "expect", "one", "of", "the", "following", "two", "instruction", "sequences", ":", "addli", "tmp1", ",", "txt_label_reg", ",", "lo16", "(", "sym", "-", "txt_label", ")", "auli", "tmp2", ",", "tmp1", ",", "ha16", "(", "sym", "-", "txt_label", ")", "auli", "tmp1", ",", "txt_label_reg", ",", "ha16", "(", "sym", "-", "txt_label", ")", "addli", "tmp2", ",", "tmp1", ",", "lo16", "(", "sym", "-", "txt_label", ")", "If", "we", "'re", "compiling", "-fpic", ",", "we", "replace", "the", "first", "instruction", "with", "nothing", ",", "and", "the", "second", "instruction", "with", ":", "addli", "tmp2", ",", "got_rtx", ",", "got", "(", "sym", ")", "lw", "tmp2", ",", "tmp2", "If", "we", "'re", "compiling", "-fPIC", ",", "we", "replace", "the", "first", "instruction", "with", ":", "auli", "tmp1", ",", "got_rtx", ",", "got_ha16", "(", "sym", ")", "and", "the", "second", "instruction", "with", ":", "addli", "tmp2", ",", "tmp1", ",", "got_lo16", "(", "sym", ")", "lw", "tmp2", ",", "tmp2", "Note", "that", "we", "'re", "careful", "to", "disturb", "the", "instruction", "sequence", "as", "little", "as", "possible", ",", "since", "it", "'s", "very", "late", "in", "the", "compilation", "process", "." ]

[ "tilepro" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Kernel Attributes\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Kernel Attributes\"" ]

[]

[ "<s>", "bool", "NVPTXLowerArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "return", "isKernelFunction", "(", "F", ")", "?", "runOnKernelFunction", "(", "F", ")", ":", "runOnDeviceFunction", "(", "F", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "bool", "rs6000_slow_unaligned_access", "(", "machine_mode", "mode", ",", "unsigned", "int", "align", ")", "{", "return", "(", "STRICT_ALIGNMENT", "||", "(", "!", "TARGET_EFFICIENT_UNALIGNED_VSX", "&&", "(", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "mode", ")", "&&", "align", "<", "32", ")", "||", "(", "(", "VECTOR_MODE_P", "(", "mode", ")", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "&&", "(", "int", ")", "align", "<", "VECTOR_ALIGN", "(", "mode", ")", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SLOW_UNALIGNED_ACCESS", ".", "Altivec", "vector", "memory", "instructions", "simply", "ignore", "the", "low", "bits", ";", "VSX", "memory", "instructions", "are", "aligned", "to", "4", "or", "8", "bytes", "." ]

[ "powerpcspe", "32" ]

[]

[ "<s>", "DecodeStatus", "TeeRISCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Region", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableTeeRISC32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "TeeRISC", "TeeRISC", "TeeRISC", "4" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "BackChain", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"backchain\"", ")", ";", "if", "(", "!", "usePackedStack", "(", "MF", ")", "||", "BackChain", ")", "getOrCreateFramePointerSaveIndex", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "(", "MFFrame", ".", "estimateStackSize", "(", "MF", ")", "+", "SystemZMC", "::", "CallFrameSize", ")", ";", "int64_t", "MaxArgOffset", "=", "0", ";", "for", "(", "int", "I", "=", "MFFrame", ".", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "if", "(", "MFFrame", ".", "getObjectOffset", "(", "I", ")", ">=", "0", ")", "{", "int64_t", "ArgOffset", "=", "MFFrame", ".", "getObjectOffset", "(", "I", ")", "+", "MFFrame", ".", "getObjectSize", "(", "I", ")", ";", "MaxArgOffset", "=", "std", "::", "max", "(", "MaxArgOffset", ",", "ArgOffset", ")", ";", "}", "uint64_t", "MaxReach", "=", "StackSize", "+", "MaxArgOffset", ";", "if", "(", "!", "isUInt", "<", "12", ">", "(", "MaxReach", ")", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "Align", "(", "8", ")", ",", "false", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "Align", "(", "8", ")", ",", "false", ")", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"backchain\"", "SystemZMC::CallFrameSize", "0", "0", "0", "12", "8", "8", "8", "8" ]

[]

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

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "AMDGPUPropagateAttributesLate", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ")", "{", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "TM", "=", "&", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "}", "return", "AMDGPUPropagateAttributes", "(", "TM", ",", "true", ")", ".", "process", "(", "M", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "nios2_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_RETVAL_REGNO", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_output_readonly_section_asm_op", "(", "const", "char", "*", "directive", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.csect %s[RO],%s\\n\"", ",", "directive", "?", "xcoff_private_rodata_section_name", ":", "xcoff_read_only_section_name", ",", "XCOFF_CSECT_DEFAULT_ALIGNMENT_STR", ")", ";", "}", "</s>" ]

[ "A", "get_unnamed_decl", "callback", ",", "used", "for", "read-only", "sections", ".", "PTR", "points", "to", "the", "section", "string", "variable", "." ]

[ "rs6000", "\"\\t.csect %s[RO],%s\\n\"" ]

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "const", "MCSymbolRefExpr", "*", "A", "=", "Target", ".", "getSymA", "(", ")", ";", "const", "MCSymbol", "*", "Sym", "=", "A", "?", "&", "A", "->", "getSymbol", "(", ")", ":", "nullptr", ";", "const", "unsigned", "FixupKind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "FixupKind", "==", "FK_NONE", ")", "return", "true", ";", "if", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_bl", ")", "{", "assert", "(", "Sym", "&&", "\"How did we resolve this?\"", ")", ";", "if", "(", "Sym", "->", "isExternal", "(", ")", ")", "return", "true", ";", "}", "if", "(", "Sym", "&&", "Sym", "->", "isELF", "(", ")", ")", "{", "unsigned", "Type", "=", "cast", "<", "MCSymbolELF", ">", "(", "Sym", ")", "->", "getType", "(", ")", ";", "if", "(", "(", "Type", "==", "ELF", "::", "STT_FUNC", "||", "Type", "==", "ELF", "::", "STT_GNU_IFUNC", ")", ")", "{", "if", "(", "Asm", ".", "isThumbFunc", "(", "Sym", ")", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_uncondbranch", ")", ")", "return", "true", ";", "if", "(", "!", "Asm", ".", "isThumbFunc", "(", "Sym", ")", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_br", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_bl", "||", "FixupKind", "==", "ARM", "::", "fixup_t2_condbranch", "||", "FixupKind", "==", "ARM", "::", "fixup_t2_uncondbranch", ")", ")", "return", "true", ";", "}", "}", "if", "(", "A", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_blx", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_blx", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_uncondbl", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_condbl", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "ARM", "ARM", "ARM::fixup_arm_thumb_bl", "\"How did we resolve this?\"", "ARM::fixup_arm_uncondbranch", "ARM::fixup_arm_thumb_br", "ARM::fixup_arm_thumb_bl", "ARM::fixup_t2_condbranch", "ARM::fixup_t2_uncondbranch", "ARM::fixup_arm_thumb_blx", "ARM::fixup_arm_blx", "ARM::fixup_arm_uncondbl", "ARM::fixup_arm_condbl" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "SW", ":", "RISCV", "::", "SD", ";", "else", "if", "(", "RISCV", "::", "FPR16RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSH", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSD", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::SW", "RISCV::SD", "RISCV::FPR16RegClass", "RISCV::FSH", "RISCV::FPR32RegClass", "RISCV::FSW", "RISCV::FPR64RegClass", "RISCV::FSD", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "static", "int", "pa_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "unsigned", "int", "max_arg_words", "=", "8", ";", "unsigned", "int", "offset", "=", "0", ";", "int", "arg_size", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", "0", ";", "arg_size", "=", "pa_function_arg_size", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "arg_size", ">", "1", "&&", "(", "cum", "->", "words", "&", "1", ")", ")", "offset", "=", "1", ";", "if", "(", "cum", "->", "words", "+", "offset", "+", "arg_size", "<=", "max_arg_words", ")", "return", "0", ";", "else", "if", "(", "cum", "->", "words", "+", "offset", ">=", "max_arg_words", ")", "return", "0", ";", "else", "return", "(", "max_arg_words", "-", "cum", "->", "words", "-", "offset", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "If", "this", "arg", "would", "be", "passed", "totally", "in", "registers", "or", "totally", "on", "the", "stack", ",", "then", "this", "routine", "should", "return", "zero", "." ]

[ "pa", "8", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "BPFAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "if", "(", "MAI", "->", "doesSupportDebugInformation", "(", ")", "&&", "!", "empty", "(", "M", ".", "debug_compile_units", "(", ")", ")", ")", "{", "Handlers", ".", "emplace_back", "(", "llvm", "::", "make_unique", "<", "BTFDebug", ">", "(", "this", ")", ",", "\"emit\"", ",", "\"Debug Info Emission\"", ",", "\"BTF\"", ",", "\"BTF Emission\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"emit\"", "\"Debug Info Emission\"", "\"BTF\"", "\"BTF Emission\"" ]

[]

[ "<s>", "bool", "CJGPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createCJGISelDag", "(", "getCJGTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "CJG", "CJG", "CJG", "CJG" ]

[]

[ "<s>", "void", "bb_sese", "::", "append", "(", "bb_sese", "*", "child", ")", "{", "if", "(", "int", "len", "=", "child", "->", "brackets", ".", "length", "(", ")", ")", "{", "int", "ix", ";", "if", "(", "dump_file", ")", "{", "for", "(", "ix", "=", "0", ";", "ix", "<", "len", ";", "ix", "++", ")", "{", "const", "pseudo_node_t", "&", "pseudo", "=", "child", "->", "brackets", "[", "ix", "]", ".", "back", ";", "fprintf", "(", "dump_file", ",", "\"Appending (%d)'s backedge %d:%+d\\n\"", ",", "child", "->", "node", ",", "pseudo", ".", "first", "?", "pseudo", ".", "first", "->", "index", ":", "0", ",", "pseudo", ".", "second", ")", ";", "}", "}", "if", "(", "!", "brackets", ".", "length", "(", ")", ")", "std", "::", "swap", "(", "brackets", ",", "child", "->", "brackets", ")", ";", "else", "{", "brackets", ".", "reserve", "(", "len", ")", ";", "for", "(", "ix", "=", "0", ";", "ix", "<", "len", ";", "ix", "++", ")", "brackets", ".", "quick_push", "(", "child", "->", "brackets", "[", "ix", "]", ")", ";", "}", "}", "}", "</s>" ]

[ "Destructively", "append", "CHILD", "'s", "brackets", "." ]

[ "nvptx", "0", "\"Appending (%d)'s backedge %d:%+d\\n\"", "0", "0" ]

[]

[ "<s>", "static", "bool", "arm_valid_target_attribute_rec", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "bool", "ret", "=", "true", ";", "for", "(", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "!", "arm_valid_target_attribute_rec", "(", "TREE_VALUE", "(", "args", ")", ",", "opts", ")", ")", "ret", "=", "false", ";", "return", "ret", ";", "}", "else", "if", "(", "TREE_CODE", "(", "args", ")", "!=", "STRING_CST", ")", "{", "error", "(", "\"attribute %<target%> argument not a string\"", ")", ";", "return", "false", ";", "}", "char", "*", "argstr", "=", "ASTRDUP", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "q", ";", "while", "(", "(", "q", "=", "strtok", "(", "argstr", ",", "\",\"", ")", ")", "!=", "NULL", ")", "{", "argstr", "=", "NULL", ";", "if", "(", "!", "strcmp", "(", "q", ",", "\"thumb\"", ")", ")", "opts", "->", "x_target_flags", "|=", "MASK_THUMB", ";", "else", "if", "(", "!", "strcmp", "(", "q", ",", "\"arm\"", ")", ")", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "else", "if", "(", "!", "strcmp", "(", "q", ",", "\"general-regs-only\"", ")", ")", "opts", "->", "x_target_flags", "|=", "MASK_GENERAL_REGS_ONLY", ";", "else", "if", "(", "!", "strncmp", "(", "q", ",", "\"fpu=\"", ",", "4", ")", ")", "{", "int", "fpu_index", ";", "if", "(", "!", "opt_enum_arg_to_value", "(", "OPT_mfpu_", ",", "q", "+", "4", ",", "&", "fpu_index", ",", "CL_TARGET", ")", ")", "{", "error", "(", "\"invalid fpu for target attribute or pragma %qs\"", ",", "q", ")", ";", "return", "false", ";", "}", "if", "(", "fpu_index", "==", "TARGET_FPU_auto", ")", "{", "sorry", "(", "\"auto fpu selection not currently permitted here\"", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_fpu_index", "=", "(", "enum", "fpu_type", ")", "fpu_index", ";", "}", "else", "if", "(", "!", "strncmp", "(", "q", ",", "\"arch=\"", ",", "5", ")", ")", "{", "char", "*", "arch", "=", "q", "+", "5", ";", "const", "arch_option", "*", "arm_selected_arch", "=", "arm_parse_arch_option_name", "(", "all_architectures", ",", "\"arch\"", ",", "arch", ")", ";", "if", "(", "!", "arm_selected_arch", ")", "{", "error", "(", "\"invalid architecture for target attribute or pragma %qs\"", ",", "q", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_arch_string", "=", "xstrndup", "(", "arch", ",", "strlen", "(", "arch", ")", ")", ";", "}", "else", "if", "(", "q", "[", "0", "]", "==", "'+'", ")", "{", "opts", "->", "x_arm_arch_string", "=", "xasprintf", "(", "\"%s%s\"", ",", "opts", "->", "x_arm_arch_string", ",", "q", ")", ";", "}", "else", "{", "error", "(", "\"unknown target attribute or pragma %qs\"", ",", "q", ")", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Inner", "function", "to", "process", "the", "attribute", "(", "(", "target", "(", "...", ")", ")", ")", ",", "take", "an", "argument", "and", "set", "the", "current", "options", "from", "the", "argument", ".", "If", "we", "have", "a", "list", ",", "recursively", "go", "over", "the", "list", "." ]

[ "arm", "\"attribute %<target%> argument not a string\"", "\",\"", "\"thumb\"", "\"arm\"", "\"general-regs-only\"", "\"fpu=\"", "4", "4", "\"invalid fpu for target attribute or pragma %qs\"", "\"auto fpu selection not currently permitted here\"", "\"arch=\"", "5", "5", "\"arch\"", "\"invalid architecture for target attribute or pragma %qs\"", "0", "\"%s%s\"", "\"unknown target attribute or pragma %qs\"" ]

[]

[ "<s>", "static", "void", "rs6000_set_default_type_attributes", "(", "tree", "type", ")", "{", "if", "(", "rs6000_default_long_calls", "&&", "(", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", ")", ")", "TYPE_ATTRIBUTES", "(", "type", ")", "=", "tree_cons", "(", "get_identifier", "(", "\"longcall\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "}", "</s>" ]

[ "Set", "longcall", "attributes", "on", "all", "functions", "declared", "when", "rs6000_default_long_calls", "is", "true", "." ]

[ "rs6000", "\"longcall\"" ]

[]

[ "<s>", "static", "void", "rs6000_function_specific_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ")", "{", "ptr", "->", "x_rs6000_isa_flags", "=", "opts", "->", "x_rs6000_isa_flags", ";", "ptr", "->", "x_rs6000_isa_flags_explicit", "=", "opts", "->", "x_rs6000_isa_flags_explicit", ";", "}", "</s>" ]

[ "Save", "the", "current", "options" ]

[ "rs6000" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "StringRef", "WinEHParentName", "=", "F", ".", "getFnAttribute", "(", "\"wineh-parent\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "WinEHParentName", "!=", "F", ".", "getName", "(", ")", "&&", "!", "WinEHParentName", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isFuncletEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "if", "(", "WinEHParentName", ".", "empty", "(", ")", ")", "{", "bool", "HasPads", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "if", "(", "BB", ".", "isEHPad", "(", ")", ")", "{", "HasPads", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasPads", ")", "return", "false", ";", "}", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "auto", "*", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "std", "::", "unique_ptr", "<", "WinEHFuncInfo", ">", "FuncInfoPtr", ";", "if", "(", "!", "MMI", ")", "FuncInfoPtr", ".", "reset", "(", "new", "WinEHFuncInfo", "(", ")", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "*", "(", "MMI", "?", "&", "MMI", "->", "getWinEHFuncInfo", "(", "&", "F", ")", ":", "FuncInfoPtr", ".", "get", "(", ")", ")", ";", "FuncInfo", ".", "EHRegNode", "=", "RegNode", ";", "switch", "(", "Personality", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected personality function\"", ")", ";", "case", "EHPersonality", "::", "MSVC_CXX", ":", "addCXXStateStores", "(", "F", ",", "FuncInfo", ")", ";", "break", ";", "case", "EHPersonality", "::", "MSVC_X86SEH", ":", "addSEHStateStores", "(", "F", ",", "FuncInfo", ")", ";", "break", ";", "}", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"wineh-parent\"", "\"no-frame-pointer-elim\"", "\"true\"", "\"unexpected personality function\"", "X86" ]

[]

[ "<s>", "static", "void", "aarch64_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "rtx", "reg1", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROBE_STACK_FIRST_REG", ")", ";", "gcc_assert", "(", "(", "first", "%", "ARITH_FACTOR", ")", "==", "0", ")", ";", "if", "(", "size", "<=", "PROBE_INTERVAL", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "size", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "base", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg1", ",", "base", "-", "size", ")", ")", ";", "}", "else", "if", "(", "size", "<=", "4", "*", "PROBE_INTERVAL", ")", "{", "HOST_WIDE_INT", "i", ",", "rem", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "PROBE_INTERVAL", ")", ")", ")", ";", "emit_stack_probe", "(", "reg1", ")", ";", "for", "(", "i", "=", "2", "*", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "{", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "reg1", ",", "-", "PROBE_INTERVAL", ")", ")", ";", "emit_stack_probe", "(", "reg1", ")", ";", "}", "rem", "=", "size", "-", "(", "i", "-", "PROBE_INTERVAL", ")", ";", "if", "(", "rem", ">", "256", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "rem", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "reg1", ",", "-", "base", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg1", ",", "base", "-", "rem", ")", ")", ";", "}", "else", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg1", ",", "-", "rem", ")", ")", ";", "}", "else", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROBE_STACK_SECOND_REG", ")", ";", "HOST_WIDE_INT", "rounded_size", "=", "size", "&", "-", "PROBE_INTERVAL", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "first", ")", ")", ";", "emit_set_insn", "(", "reg2", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "rounded_size", ")", ")", ")", ";", "emit_insn", "(", "gen_probe_stack_range", "(", "reg1", ",", "reg1", ",", "reg2", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "{", "HOST_WIDE_INT", "rem", "=", "size", "-", "rounded_size", ";", "if", "(", "rem", ">", "256", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "rem", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg2", ",", "plus_constant", "(", "Pmode", ",", "reg2", ",", "-", "base", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg2", ",", "base", "-", "rem", ")", ")", ";", "}", "else", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg2", ",", "-", "rem", ")", ")", ";", "}", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "aarch64", "0", "4", "2", "256", "256" ]

[]

[ "<s>", "static", "inline", "bool", "m32r_legitimate_lo_sum_addres_p", "(", "machine_mode", "mode", ",", "const_rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "(", "mode", "!=", "BLKmode", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", "&&", "m32r_rtx_ok_for_base_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "For", "LO_SUM", "addresses", ",", "do", "not", "allow", "them", "if", "the", "MODE", "is", ">", "1", "word", ",", "since", "more", "than", "one", "instruction", "will", "be", "required", "." ]

[ "m32r", "0", "1" ]

[]

[ "<s>", "bool", "ARM64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "assert", "(", "!", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "&&", "\"No stack realignment on ARM64!\"", ")", ";", "return", "(", "MFI", "->", "hasCalls", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"No stack realignment on ARM64!\"" ]

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_symbolic_expression", "(", "rtx", "x", ",", "enum", "aarch64_symbol_context", "context", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "return", "aarch64_classify_symbol", "(", "x", ",", "offset", ",", "context", ")", ";", "}", "</s>" ]

[ "Classify", "the", "base", "of", "symbolic", "expression", "X", ",", "given", "that", "X", "appears", "in", "context", "CONTEXT", "." ]

[ "aarch64" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon bit simplification\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon bit simplification\"" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "arm_asan_shadow_offset", "(", "void", ")", "{", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "29", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_ASAN_SHADOW_OFFSET", "hook", "." ]

[ "arm", "1", "29" ]

[]

[ "<s>", "static", "rtx", "arc_get_tp", "(", "void", ")", "{", "if", "(", "arc_tp_regno", "!=", "-", "1", ")", "return", "gen_rtx_REG", "(", "Pmode", ",", "arc_tp_regno", ")", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tls_load_tp_soft", "(", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Get", "the", "thread", "pointer", "." ]

[ "arc", "1" ]

[]

[ "<s>", "static", "int", "get_some_local_dynamic_name_1", "(", "rtx", "*", "px", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "x", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "{", "cfun", "->", "machine", "->", "some_ld_name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "See", "'get_some_local_dynamic_name", "'", "." ]

[ "sparc", "0", "1", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MSP430 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "output_move_double", "(", "rtx", "*", "operands", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "register_operand", "(", "dst", ",", "mode", ")", "&&", "register_operand", "(", "src", ",", "mode", ")", ")", "{", "if", "(", "REGNO", "(", "src", ")", "+", "1", "==", "REGNO", "(", "dst", ")", ")", "return", "\"mov %R1,%R0\\n\\tmov %1,%0\"", ";", "else", "return", "\"mov %1,%0\\n\\tmov %R1,%R0\"", ";", "}", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", "&&", "(", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src", ")", "==", "0", ")", "||", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "CONST_DOUBLE_OK_FOR_G", "(", "src", ")", ")", ")", ")", "return", "\"st.w %.,%0\\n\\tst.w %.,%R0\"", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "{", "HOST_WIDE_INT", "high_low", "[", "2", "]", ";", "int", "i", ";", "rtx", "xop", "[", "10", "]", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "const_double_split", "(", "src", ",", "&", "high_low", "[", "1", "]", ",", "&", "high_low", "[", "0", "]", ")", ";", "else", "{", "high_low", "[", "0", "]", "=", "INTVAL", "(", "src", ")", ";", "high_low", "[", "1", "]", "=", "(", "INTVAL", "(", "src", ")", ">=", "0", ")", "?", "0", ":", "-", "1", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "xop", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "dst", ")", "+", "i", ")", ";", "xop", "[", "1", "]", "=", "GEN_INT", "(", "high_low", "[", "i", "]", ")", ";", "output_asm_insn", "(", "output_move_single", "(", "xop", ")", ",", "xop", ")", ";", "}", "return", "\"\"", ";", "}", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "int", "ptrreg", "=", "-", "1", ";", "int", "dreg", "=", "REGNO", "(", "dst", ")", ";", "rtx", "inside", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "inside", ")", "==", "REG", ")", "ptrreg", "=", "REGNO", "(", "inside", ")", ";", "else", "if", "(", "GET_CODE", "(", "inside", ")", "==", "SUBREG", ")", "ptrreg", "=", "subreg_regno", "(", "inside", ")", ";", "else", "if", "(", "GET_CODE", "(", "inside", ")", "==", "PLUS", ")", "ptrreg", "=", "REGNO", "(", "XEXP", "(", "inside", ",", "0", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "inside", ")", "==", "LO_SUM", ")", "ptrreg", "=", "REGNO", "(", "XEXP", "(", "inside", ",", "0", ")", ")", ";", "if", "(", "dreg", "==", "ptrreg", ")", "return", "\"ld.w %R1,%R0\\n\\tld.w %1,%0\"", ";", "}", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "return", "\"ld.w %1,%0\\n\\tld.w %R1,%R0\"", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", ")", "return", "\"st.w %1,%0\\n\\tst.w %R1,%R0\"", ";", "return", "\"mov %1,%0\\n\\tmov %R1,%R0\"", ";", "}", "</s>" ]

[ "Return", "appropriate", "code", "to", "load", "up", "an", "8", "byte", "integer", "or", "floating", "point", "value" ]

[ "v850", "0", "0", "1", "1", "\"mov %R1,%R0\\n\\tmov %1,%0\"", "\"mov %1,%0\\n\\tmov %R1,%R0\"", "0", "\"st.w %.,%0\\n\\tst.w %.,%R0\"", "2", "10", "1", "0", "0", "1", "0", "0", "1", "0", "2", "0", "1", "\"\"", "1", "0", "0", "0", "\"ld.w %R1,%R0\\n\\tld.w %1,%0\"", "\"ld.w %1,%0\\n\\tld.w %R1,%R0\"", "\"st.w %1,%0\\n\\tst.w %R1,%R0\"", "\"mov %1,%0\\n\\tmov %R1,%R0\"" ]

[]

[ "<s>", "rtx", "aarch64_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "int", "icode", ";", "rtx", "pat", ",", "op0", ";", "tree", "arg0", ";", "switch", "(", "fcode", ")", "{", "case", "AARCH64_BUILTIN_GET_FPCR", ":", "case", "AARCH64_BUILTIN_SET_FPCR", ":", "case", "AARCH64_BUILTIN_GET_FPSR", ":", "case", "AARCH64_BUILTIN_SET_FPSR", ":", "if", "(", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPCR", ")", "||", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPSR", ")", ")", "{", "icode", "=", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPSR", ")", "?", "CODE_FOR_get_fpsr", ":", "CODE_FOR_get_fpcr", ";", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "}", "else", "{", "target", "=", "NULL_RTX", ";", "icode", "=", "(", "fcode", "==", "AARCH64_BUILTIN_SET_FPSR", ")", "?", "CODE_FOR_set_fpsr", ":", "CODE_FOR_set_fpcr", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "force_reg", "(", "SImode", ",", "expand_normal", "(", "arg0", ")", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ")", ";", "}", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "case", "AARCH64_PAUTH_BUILTIN_AUTIA1716", ":", "case", "AARCH64_PAUTH_BUILTIN_PACIA1716", ":", "case", "AARCH64_PAUTH_BUILTIN_XPACLRI", ":", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "force_reg", "(", "Pmode", ",", "expand_normal", "(", "arg0", ")", ")", ";", "if", "(", "!", "target", ")", "target", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "else", "target", "=", "force_reg", "(", "Pmode", ",", "target", ")", ";", "emit_move_insn", "(", "target", ",", "op0", ")", ";", "if", "(", "fcode", "==", "AARCH64_PAUTH_BUILTIN_XPACLRI", ")", "{", "rtx", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "R30_REGNUM", ")", ";", "icode", "=", "CODE_FOR_xpaclri", ";", "emit_move_insn", "(", "lr", ",", "op0", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", ")", ")", ";", "emit_move_insn", "(", "target", ",", "lr", ")", ";", "}", "else", "{", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "rtx", "op1", "=", "force_reg", "(", "Pmode", ",", "expand_normal", "(", "arg1", ")", ")", ";", "icode", "=", "(", "fcode", "==", "AARCH64_PAUTH_BUILTIN_PACIA1716", "?", "CODE_FOR_paci1716", ":", "CODE_FOR_auti1716", ")", ";", "rtx", "x16_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "R16_REGNUM", ")", ";", "rtx", "x17_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "R17_REGNUM", ")", ";", "emit_move_insn", "(", "x17_reg", ",", "op0", ")", ";", "emit_move_insn", "(", "x16_reg", ",", "op1", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", ")", ")", ";", "emit_move_insn", "(", "target", ",", "x17_reg", ")", ";", "}", "return", "target", ";", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ0_V2SF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ90_V2SF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ180_V2SF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ270_V2SF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ0_V4HF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ90_V4HF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ180_V4HF", ":", "case", "AARCH64_SIMD_BUILTIN_FCMLA_LANEQ270_V4HF", ":", "return", "aarch64_expand_fcmla_builtin", "(", "exp", ",", "target", ",", "fcode", ")", ";", "}", "if", "(", "fcode", ">=", "AARCH64_SIMD_BUILTIN_BASE", "&&", "fcode", "<=", "AARCH64_SIMD_BUILTIN_MAX", ")", "return", "aarch64_simd_expand_builtin", "(", "fcode", ",", "exp", ",", "target", ")", ";", "else", "if", "(", "fcode", ">=", "AARCH64_CRC32_BUILTIN_BASE", "&&", "fcode", "<=", "AARCH64_CRC32_BUILTIN_MAX", ")", "return", "aarch64_crc32_expand_builtin", "(", "fcode", ",", "exp", ",", "target", ")", ";", "if", "(", "fcode", "==", "AARCH64_BUILTIN_RSQRT_DF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_SF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_V2DF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_V2SF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_V4SF", ")", "return", "aarch64_expand_builtin_rsqrt", "(", "fcode", ",", "exp", ",", "target", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", "." ]

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

[]

[ "<s>", "rtx", "ix86_memtag_set_tag", "(", "rtx", "untagged", ",", "rtx", "tag", ",", "rtx", "target", ")", "{", "if", "(", "ix86_lam_type", "==", "lam_u57", ")", "{", "unsigned", "HOST_WIDE_INT", "and_imm", "=", "(", "HOST_WIDE_INT_1U", "<<", "IX86_HWASAN_TAG_SIZE", ")", "-", "1", ";", "emit_insn", "(", "gen_andqi3", "(", "tag", ",", "tag", ",", "GEN_INT", "(", "and_imm", ")", ")", ")", ";", "}", "tag", "=", "expand_simple_binop", "(", "Pmode", ",", "ASHIFT", ",", "tag", ",", "GEN_INT", "(", "IX86_HWASAN_SHIFT", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "rtx", "ret", "=", "expand_simple_binop", "(", "Pmode", ",", "IOR", ",", "untagged", ",", "tag", ",", "target", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMTAG_SET_TAG", "." ]

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

[]

[ "<s>", "const", "SparcSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "isNoTOCCallInstr", "(", "unsigned", "Opcode", ")", "const", "{", "if", "(", "!", "get", "(", "Opcode", ")", ".", "isCall", "(", ")", ")", "return", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown call opcode\"", ")", ";", "return", "false", ";", "case", "PPC", "::", "BL8_NOTOC", ":", "case", "PPC", "::", "BL8_NOTOC_TLS", ":", "case", "PPC", "::", "BL8_NOTOC_RM", ":", "return", "true", ";", "case", "PPC", "::", "BL8", ":", "case", "PPC", "::", "BL", ":", "case", "PPC", "::", "BL8_TLS", ":", "case", "PPC", "::", "BL_TLS", ":", "case", "PPC", "::", "BLA8", ":", "case", "PPC", "::", "BLA", ":", "case", "PPC", "::", "BCCL", ":", "case", "PPC", "::", "BCCLA", ":", "case", "PPC", "::", "BCL", ":", "case", "PPC", "::", "BCLn", ":", "case", "PPC", "::", "BL8_NOP", ":", "case", "PPC", "::", "BL_NOP", ":", "case", "PPC", "::", "BL8_NOP_TLS", ":", "case", "PPC", "::", "BLA8_NOP", ":", "case", "PPC", "::", "BCTRL8", ":", "case", "PPC", "::", "BCTRL", ":", "case", "PPC", "::", "BCCCTRL8", ":", "case", "PPC", "::", "BCCCTRL", ":", "case", "PPC", "::", "BCCTRL8", ":", "case", "PPC", "::", "BCCTRL", ":", "case", "PPC", "::", "BCCTRL8n", ":", "case", "PPC", "::", "BCCTRLn", ":", "case", "PPC", "::", "BL8_RM", ":", "case", "PPC", "::", "BLA8_RM", ":", "case", "PPC", "::", "BL8_NOP_RM", ":", "case", "PPC", "::", "BLA8_NOP_RM", ":", "case", "PPC", "::", "BCTRL8_RM", ":", "case", "PPC", "::", "BCTRL8_LDinto_toc", ":", "case", "PPC", "::", "BCTRL8_LDinto_toc_RM", ":", "case", "PPC", "::", "BL8_TLS_", ":", "case", "PPC", "::", "TCRETURNdi8", ":", "case", "PPC", "::", "TCRETURNai8", ":", "case", "PPC", "::", "TCRETURNri8", ":", "case", "PPC", "::", "TAILBCTR8", ":", "case", "PPC", "::", "TAILB8", ":", "case", "PPC", "::", "TAILBA8", ":", "case", "PPC", "::", "BCLalways", ":", "case", "PPC", "::", "BLRL", ":", "case", "PPC", "::", "BCCLRL", ":", "case", "PPC", "::", "BCLRL", ":", "case", "PPC", "::", "BCLRLn", ":", "case", "PPC", "::", "BDZL", ":", "case", "PPC", "::", "BDNZL", ":", "case", "PPC", "::", "BDZLA", ":", "case", "PPC", "::", "BDNZLA", ":", "case", "PPC", "::", "BDZLp", ":", "case", "PPC", "::", "BDNZLp", ":", "case", "PPC", "::", "BDZLAp", ":", "case", "PPC", "::", "BDNZLAp", ":", "case", "PPC", "::", "BDZLm", ":", "case", "PPC", "::", "BDNZLm", ":", "case", "PPC", "::", "BDZLAm", ":", "case", "PPC", "::", "BDNZLAm", ":", "case", "PPC", "::", "BDZLRL", ":", "case", "PPC", "::", "BDNZLRL", ":", "case", "PPC", "::", "BDZLRLp", ":", "case", "PPC", "::", "BDNZLRLp", ":", "case", "PPC", "::", "BDZLRLm", ":", "case", "PPC", "::", "BDNZLRLm", ":", "case", "PPC", "::", "BL_RM", ":", "case", "PPC", "::", "BLA_RM", ":", "case", "PPC", "::", "BL_NOP_RM", ":", "case", "PPC", "::", "BCTRL_RM", ":", "case", "PPC", "::", "TCRETURNdi", ":", "case", "PPC", "::", "TCRETURNai", ":", "case", "PPC", "::", "TCRETURNri", ":", "case", "PPC", "::", "BCTRL_LWZinto_toc", ":", "case", "PPC", "::", "BCTRL_LWZinto_toc_RM", ":", "case", "PPC", "::", "TAILBCTR", ":", "case", "PPC", "::", "TAILB", ":", "case", "PPC", "::", "TAILBA", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Check", "if", "Opcode", "corresponds", "to", "a", "call", "instruction", "that", "should", "be", "marked", "with", "the", "NOTOC", "relocation", "." ]

[ "PowerPC", "\"Unknown call opcode\"", "PPC::BL8_NOTOC", "PPC::BL8_NOTOC_TLS", "PPC::BL8_NOTOC_RM", "PPC::BL8", "PPC::BL", "PPC::BL8_TLS", "PPC::BL_TLS", "PPC::BLA8", "PPC::BLA", "PPC::BCCL", "PPC::BCCLA", "PPC::BCL", "PPC::BCLn", "PPC::BL8_NOP", "PPC::BL_NOP", "PPC::BL8_NOP_TLS", "PPC::BLA8_NOP", "PPC::BCTRL8", "PPC::BCTRL", "PPC::BCCCTRL8", "PPC::BCCCTRL", "PPC::BCCTRL8", "PPC::BCCTRL", "PPC::BCCTRL8n", "PPC::BCCTRLn", "PPC::BL8_RM", "PPC::BLA8_RM", "PPC::BL8_NOP_RM", "PPC::BLA8_NOP_RM", "PPC::BCTRL8_RM", "PPC::BCTRL8_LDinto_toc", "PPC::BCTRL8_LDinto_toc_RM", "PPC::BL8_TLS_", "PPC::TCRETURNdi8", "PPC::TCRETURNai8", "PPC::TCRETURNri8", "PPC::TAILBCTR8", "PPC::TAILB8", "PPC::TAILBA8", "PPC::BCLalways", "PPC::BLRL", "PPC::BCCLRL", "PPC::BCLRL", "PPC::BCLRLn", "PPC::BDZL", "PPC::BDNZL", "PPC::BDZLA", "PPC::BDNZLA", "PPC::BDZLp", "PPC::BDNZLp", "PPC::BDZLAp", "PPC::BDNZLAp", "PPC::BDZLm", "PPC::BDNZLm", "PPC::BDZLAm", "PPC::BDNZLAm", "PPC::BDZLRL", "PPC::BDNZLRL", "PPC::BDZLRLp", "PPC::BDNZLRLp", "PPC::BDZLRLm", "PPC::BDNZLRLm", "PPC::BL_RM", "PPC::BLA_RM", "PPC::BL_NOP_RM", "PPC::BCTRL_RM", "PPC::TCRETURNdi", "PPC::TCRETURNai", "PPC::TCRETURNri", "PPC::BCTRL_LWZinto_toc", "PPC::BCTRL_LWZinto_toc_RM", "PPC::TAILBCTR", "PPC::TAILB", "PPC::TAILBA" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "*", "O", ")", "const", "{", "if", "(", "O", ")", "print", "(", "*", "O", ")", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "rtx", "mips_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "mips_function_value_1", "(", "NULL_TREE", ",", "NULL_TREE", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "mips" ]

[]

[ "<s>", "virtual", "const", "XCoreSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "AArch64TargetLowering", "::", "ConstraintType", "AArch64TargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'Y'", ":", "case", "'Z'", ":", "return", "C_Other", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'S'", ":", "return", "C_Other", ";", "}", "}", "assert", "(", "Constraint", "!=", "\"Ump\"", "&&", "Constraint", "!=", "\"Utf\"", "&&", "Constraint", "!=", "\"Usa\"", "&&", "Constraint", "!=", "\"Ush\"", "&&", "\"Unimplemented constraints\"", ")", ";", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "1", "0", "\"Ump\"", "\"Utf\"", "\"Usa\"", "\"Ush\"", "\"Unimplemented constraints\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "static", "void", "swap_const_vector_halves", "(", "rtx", "*", "op_ptr", ")", "{", "int", "i", ";", "rtx", "op", "=", "*", "op_ptr", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", ")", "{", "int", "units", "=", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "op", ")", ")", ";", "rtx_vector_builder", "builder", "(", "GET_MODE", "(", "op", ")", ",", "units", ",", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", "/", "2", ";", "++", "i", ")", "builder", ".", "quick_push", "(", "CONST_VECTOR_ELT", "(", "op", ",", "i", "+", "units", "/", "2", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", "/", "2", ";", "++", "i", ")", "builder", ".", "quick_push", "(", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ")", ";", "*", "op_ptr", "=", "builder", ".", "build", "(", ")", ";", "}", "else", "{", "int", "j", ";", "const", "char", "*", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_RTX_LENGTH", "(", "code", ")", ";", "++", "i", ")", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "||", "fmt", "[", "i", "]", "==", "'u'", ")", "swap_const_vector_halves", "(", "&", "XEXP", "(", "op", ",", "i", ")", ")", ";", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "op", ",", "i", ")", ";", "++", "j", ")", "swap_const_vector_halves", "(", "&", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ";", "}", "}", "</s>" ]

[ "OP", "is", "either", "a", "CONST_VECTOR", "or", "an", "expression", "containing", "one", ".", "Swap", "the", "first", "half", "of", "the", "vector", "with", "the", "second", "in", "the", "first", "case", ".", "Recurse", "to", "find", "it", "in", "the", "second", "." ]

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

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "getSGPRNum", "(", ")", "==", "0", "&&", "getVGPRNum", "(", "false", ")", "==", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "uint64_t", "AArch64InstrInfo", "::", "getElementSizeForOpcode", "(", "unsigned", "Opc", ")", "const", "{", "return", "get", "(", "Opc", ")", ".", "TSFlags", "&", "AArch64", "::", "ElementSizeMask", ";", "}", "</s>" ]

[ "Returns", "the", "vector", "element", "size", "(", "B", ",", "H", ",", "S", "or", "D", ")", "of", "an", "SVE", "opcode", "." ]

[ "AArch64", "AArch64", "AArch64::ElementSizeMask" ]

[]

[ "<s>", "unsigned", "MOSInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "3", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "MOS", "MOS", "3" ]

[]

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

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

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

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetRegisterInfo", "&", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "return", "0", ";", "static", "const", "unsigned", "CallerSavedRegs32Bit", "[", "]", "=", "{", "X86", "::", "EAX", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "0", "}", ";", "static", "const", "unsigned", "CallerSavedRegs64Bit", "[", "]", "=", "{", "X86", "::", "RAX", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "R8", ",", "X86", "::", "R9", ",", "X86", "::", "R10", ",", "X86", "::", "R11", ",", "0", "}", ";", "unsigned", "Opc", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETI", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "unsigned", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "const", "unsigned", "*", "AsI", "=", "TRI", ".", "getOverlaps", "(", "Reg", ")", ";", "*", "AsI", ";", "++", "AsI", ")", "Uses", ".", "insert", "(", "*", "AsI", ")", ";", "}", "const", "unsigned", "*", "CS", "=", "Is64Bit", "?", "CallerSavedRegs64Bit", ":", "CallerSavedRegs32Bit", ";", "for", "(", ";", "*", "CS", ";", "++", "CS", ")", "if", "(", "!", "Uses", ".", "count", "(", "*", "CS", ")", ")", "return", "*", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "0", "X86::EAX", "X86::EDX", "X86::ECX", "0", "X86::RAX", "X86::RDX", "X86::RCX", "X86::RSI", "X86::RDI", "X86::R8", "X86::R9", "X86::R10", "X86::R11", "0", "0", "X86::RET", "X86::RETI", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "0" ]

[]

[ "<s>", "const", "DirectXTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "DirectX" ]

[]

[ "<s>", "static", "bool", "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", ";", "}", "}", "}", "}", "return", "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", "TeakFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TeakSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "TeakSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Teak", "::", "POP_regnob16", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "Teak", "Teak", "Teak", "Teak", "0", "1", "Teak::POP_regnob16" ]

[]

[ "<s>", "void", "riscv_split_doubleword_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "rtx", "low_dest", ";", "low_dest", "=", "riscv_subword", "(", "dest", ",", "false", ")", ";", "if", "(", "REG_P", "(", "low_dest", ")", "&&", "reg_overlap_mentioned_p", "(", "low_dest", ",", "src", ")", ")", "{", "riscv_emit_move", "(", "riscv_subword", "(", "dest", ",", "true", ")", ",", "riscv_subword", "(", "src", ",", "true", ")", ")", ";", "riscv_emit_move", "(", "low_dest", ",", "riscv_subword", "(", "src", ",", "false", ")", ")", ";", "}", "else", "{", "riscv_emit_move", "(", "low_dest", ",", "riscv_subword", "(", "src", ",", "false", ")", ")", ";", "riscv_emit_move", "(", "riscv_subword", "(", "dest", ",", "true", ")", ",", "riscv_subword", "(", "src", ",", "true", ")", ")", ";", "}", "}", "</s>" ]

[ "Split", "a", "doubleword", "move", "from", "SRC", "to", "DEST", ".", "On", "32-bit", "targets", ",", "this", "function", "handles", "64-bit", "moves", "for", "which", "riscv_split_64bit_move_p", "holds", ".", "For", "64-bit", "targets", ",", "this", "function", "handles", "128-bit", "moves", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "void", "v850_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"0[\"", ")", ";", "v850_print_operand", "(", "file", ",", "addr", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "case", "LO_SUM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "{", "fprintf", "(", "file", ",", "\"lo(\"", ")", ";", "v850_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\")[\"", ")", ";", "v850_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "}", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "SUBREG", ")", "{", "v850_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "v850_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "}", "else", "{", "v850_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "v850_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "}", "break", ";", "case", "SYMBOL_REF", ":", "{", "const", "char", "*", "off_name", "=", "NULL", ";", "const", "char", "*", "reg_name", "=", "NULL", ";", "if", "(", "SYMBOL_REF_ZDA_P", "(", "addr", ")", ")", "{", "off_name", "=", "\"zdaoff\"", ";", "reg_name", "=", "\"r0\"", ";", "}", "else", "if", "(", "SYMBOL_REF_SDA_P", "(", "addr", ")", ")", "{", "off_name", "=", "\"sdaoff\"", ";", "reg_name", "=", "\"gp\"", ";", "}", "else", "if", "(", "SYMBOL_REF_TDA_P", "(", "addr", ")", ")", "{", "off_name", "=", "\"tdaoff\"", ";", "reg_name", "=", "\"ep\"", ";", "}", "if", "(", "off_name", ")", "fprintf", "(", "file", ",", "\"%s(\"", ",", "off_name", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "reg_name", ")", "fprintf", "(", "file", ",", "\")[%s]\"", ",", "reg_name", ")", ";", "}", "break", ";", "case", "CONST", ":", "if", "(", "special_symbolref_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "const", "char", "*", "off_name", ";", "const", "char", "*", "reg_name", ";", "if", "(", "SYMBOL_REF_ZDA_P", "(", "x", ")", ")", "{", "off_name", "=", "\"zdaoff\"", ";", "reg_name", "=", "\"r0\"", ";", "}", "else", "if", "(", "SYMBOL_REF_SDA_P", "(", "x", ")", ")", "{", "off_name", "=", "\"sdaoff\"", ";", "reg_name", "=", "\"gp\"", ";", "}", "else", "if", "(", "SYMBOL_REF_TDA_P", "(", "x", ")", ")", "{", "off_name", "=", "\"tdaoff\"", ";", "reg_name", "=", "\"ep\"", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "fprintf", "(", "file", ",", "\"%s(\"", ",", "off_name", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")[%s]\"", ",", "reg_name", ")", ";", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Output", "assembly", "language", "output", "for", "the", "address", "ADDR", "to", "FILE", "." ]

[ "v850", "\"0[\"", "0", "\"]\"", "0", "\"lo(\"", "1", "0", "\")[\"", "0", "0", "\"]\"", "0", "0", "1", "0", "\"[\"", "0", "0", "\"]\"", "0", "0", "\"+\"", "1", "0", "\"zdaoff\"", "\"r0\"", "\"sdaoff\"", "\"gp\"", "\"tdaoff\"", "\"ep\"", "\"%s(\"", "\")[%s]\"", "0", "0", "\"zdaoff\"", "\"r0\"", "\"sdaoff\"", "\"gp\"", "\"tdaoff\"", "\"ep\"", "\"%s(\"", "\")[%s]\"" ]

[]

[ "<s>", "void", "R600MCCodeEmitter", "::", "Emit", "(", "uint64_t", "Value", ",", "raw_ostream", "&", "OS", ")", "const", "{", "support", "::", "endian", "::", "write", "(", "OS", ",", "Value", ",", "support", "::", "little", ")", ";", "}", "</s>" ]

[ "Emit", "-", "Top", "level", "entry", "point", "." ]

[ "AMDGPU", "R600", "support::endian", "support::little" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "for", "(", "auto", "*", "GV", ":", "AFI", "->", "getGlobalsPromotedToConstantPool", "(", ")", ")", "PromotedGlobals", ".", "insert", "(", "GV", ")", ";", "unsigned", "OptimizationGoal", ";", "if", "(", "F", ".", "hasOptNone", "(", ")", ")", "OptimizationGoal", "=", "6", ";", "else", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "OptimizationGoal", "=", "4", ";", "else", "if", "(", "F", ".", "hasOptSize", "(", ")", ")", "OptimizationGoal", "=", "3", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "OptimizationGoal", "=", "2", ";", "else", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "OptimizationGoal", "=", "1", ";", "else", "OptimizationGoal", "=", "5", ";", "if", "(", "OptimizationGoals", "==", "-", "1", ")", "OptimizationGoals", "=", "OptimizationGoal", ";", "else", "if", "(", "OptimizationGoals", "!=", "(", "int", ")", "OptimizationGoal", ")", "OptimizationGoals", "=", "0", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Internal", "=", "F", ".", "hasInternalLinkage", "(", ")", ";", "COFF", "::", "SymbolStorageClass", "Scl", "=", "Internal", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ";", "int", "Type", "=", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Scl", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "Type", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "if", "(", "!", "ThumbIndirectPads", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "EmitAlignment", "(", "Align", "(", "2", ")", ")", ";", "for", "(", "std", "::", "pair", "<", "unsigned", ",", "MCSymbol", "*", ">", "&", "TIP", ":", "ThumbIndirectPads", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "TIP", ".", "second", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCInstBuilder", "(", "ARM", "::", "tBX", ")", ".", "addReg", "(", "TIP", ".", "first", ")", ".", "addImm", "(", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ")", ";", "}", "ThumbIndirectPads", ".", "clear", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "6", "4", "3", "2", "1", "5", "1", "0", "2", "ARM::tBX", "ARMCC::AL", "0" ]

[]

[ "<s>", "void", "TOYInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "TOY", "TOY" ]

[]

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

[ "Handle", "an", "``", "interrupt", "''", "attribute", "." ]

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

[]

[ "<s>", "void", "s390_output_pool_entry", "(", "rtx", "exp", ",", "machine_mode", "mode", ",", "unsigned", "int", "align", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_FLOAT", ":", "case", "MODE_DECIMAL_FLOAT", ":", "gcc_assert", "(", "GET_CODE", "(", "exp", ")", "==", "CONST_DOUBLE", ")", ";", "assemble_real", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "exp", ")", ",", "mode", ",", "align", ")", ";", "break", ";", "case", "MODE_INT", ":", "assemble_integer", "(", "exp", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "align", ",", "1", ")", ";", "mark_symbol_refs_as_used", "(", "exp", ")", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "case", "MODE_VECTOR_FLOAT", ":", "{", "int", "i", ";", "machine_mode", "inner_mode", ";", "gcc_assert", "(", "GET_CODE", "(", "exp", ")", "==", "CONST_VECTOR", ")", ";", "inner_mode", "=", "GET_MODE_INNER", "(", "GET_MODE", "(", "exp", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "exp", ",", "0", ")", ";", "i", "++", ")", "s390_output_pool_entry", "(", "XVECEXP", "(", "exp", ",", "0", ",", "i", ")", ",", "inner_mode", ",", "i", "==", "0", "?", "align", ":", "GET_MODE_BITSIZE", "(", "inner_mode", ")", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "constant", "pool", "entry", "EXP", "in", "mode", "MODE", "with", "alignment", "ALIGN", "." ]

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

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "static_cast", "<", "VLIWMachineScheduler", "*", ">", "(", "dag", ")", ";", "SchedModel", "=", "DAG", "->", "getSchedModel", "(", ")", ";", "Top", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "Bot", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "DAG", "->", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "delete", "Top", ".", "ResourceModel", ";", "delete", "Bot", ".", "ResourceModel", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "assert", "(", "(", "!", "llvm", "::", "ForceTopDown", "||", "!", "llvm", "::", "ForceBottomUp", ")", "&&", "\"-misched-topdown incompatible with -misched-bottomup\"", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "Hexagon", "\"-misched-topdown incompatible with -misched-bottomup\"" ]

[]

[ "<s>", "void", "gas_output_limited_string", "(", "FILE", "*", "file", ",", "const", "char", "*", "str", ")", "{", "const", "unsigned", "char", "*", "_limited_str", "=", "(", "unsigned", "char", "*", ")", "str", ";", "unsigned", "ch", ";", "fprintf", "(", "file", ",", "\"%s\\\"\"", ",", "STRING_ASM_OP", ")", ";", "for", "(", ";", "(", "ch", "=", "*", "_limited_str", ")", ";", "_limited_str", "++", ")", "{", "int", "escape", ";", "switch", "(", "escape", "=", "ESCAPES", "[", "ch", "]", ")", "{", "case", "0", ":", "putc", "(", "ch", ",", "file", ")", ";", "break", ";", "case", "1", ":", "fprintf", "(", "file", ",", "\"\\\\%03o\"", ",", "ch", ")", ";", "break", ";", "default", ":", "putc", "(", "'\\\\'", ",", "file", ")", ";", "putc", "(", "escape", ",", "file", ")", ";", "break", ";", "}", "}", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "}", "</s>" ]

[ "The", "routine", "used", "to", "output", "NUL", "terminated", "strings", ".", "We", "use", "a", "special", "version", "of", "this", "for", "most", "svr4", "targets", "because", "doing", "so", "makes", "the", "generated", "assembly", "code", "more", "compact", "(", "and", "thus", "faster", "to", "assemble", ")", "as", "well", "as", "more", "readable", ",", "especially", "for", "targets", "like", "the", "i386", "(", "where", "the", "only", "alternative", "is", "to", "output", "character", "sequences", "as", "comma", "separated", "lists", "of", "numbers", ")", "." ]

[ "avr", "\"%s\\\"\"", "0", "1", "\"\\\\%03o\"", "\"\\\"\\n\"" ]

[]

[ "<s>", "virtual", "void", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileMachO", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "LSDASection", "=", "getMachOSection", "(", "\"__TEXT\"", ",", "\"__gcc_except_tab\"", ",", "0", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "\"__TEXT\"", "\"__gcc_except_tab\"", "0" ]

[]

[ "<s>", "void", "rs6000_scale_v2df", "(", "rtx", "tgt", ",", "rtx", "src", ",", "int", "scale", ")", "{", "HOST_WIDE_INT", "hwi_scale", "(", "scale", ")", ";", "REAL_VALUE_TYPE", "r_pow", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "2", ")", ";", "rtx", "elt", ";", "rtx", "scale_vec", "=", "gen_reg_rtx", "(", "V2DFmode", ")", ";", "(", "void", ")", "real_powi", "(", "&", "r_pow", ",", "DFmode", ",", "&", "dconst2", ",", "hwi_scale", ")", ";", "elt", "=", "const_double_from_real_value", "(", "r_pow", ",", "DFmode", ")", ";", "RTVEC_ELT", "(", "v", ",", "0", ")", "=", "elt", ";", "RTVEC_ELT", "(", "v", ",", "1", ")", "=", "elt", ";", "rs6000_expand_vector_init", "(", "scale_vec", ",", "gen_rtx_PARALLEL", "(", "V2DFmode", ",", "v", ")", ")", ";", "emit_insn", "(", "gen_mulv2df3", "(", "tgt", ",", "src", ",", "scale_vec", ")", ")", ";", "}", "</s>" ]

[ "Scale", "a", "V2DF", "vector", "SRC", "by", "two", "to", "the", "SCALE", "and", "place", "in", "TGT", "." ]

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

[]

[ "<s>", "static", "void", "insert_wic_for_ilb_runout", "(", "rtx_insn", "*", "first", ")", "{", "rtx_insn", "*", "insn", ";", "rtx_insn", "*", "before_4", "=", "0", ";", "rtx_insn", "*", "before_16", "=", "0", ";", "int", "addr_offset", "=", "0", ";", "int", "length", ";", "int", "wic_addr0", "=", "128", "*", "4", ";", "int", "first_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "first", ")", ")", ";", "for", "(", "insn", "=", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "addr_offset", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "first_addr", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "before_4", "==", "0", "&&", "addr_offset", "+", "length", ">=", "4", "*", "4", ")", "before_4", "=", "insn", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "return", ";", "if", "(", "before_16", "==", "0", "&&", "addr_offset", "+", "length", ">=", "14", "*", "4", ")", "before_16", "=", "insn", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "tablejump_p", "(", "insn", ",", "0", ",", "0", ")", ")", "return", ";", "if", "(", "addr_offset", "+", "length", ">=", "32", "*", "4", ")", "{", "gcc_assert", "(", "before_4", "&&", "before_16", ")", ";", "if", "(", "wic_addr0", ">", "4", "*", "4", ")", "{", "insn", "=", "emit_insn_before", "(", "gen_iprefetch", "(", "gen_int_mode", "(", "addr_offset", ",", "SImode", ")", ")", ",", "before_4", ")", ";", "recog_memoized", "(", "insn", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "before_4", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "before_4", ")", ")", ")", ";", "return", ";", "}", "}", "}", "}", "</s>" ]

[ "Heuristics", "to", "identify", "where", "to", "insert", "at", "the", "fall", "through", "path", "of", "the", "caller", "function", ".", "If", "there", "is", "a", "call", "after", "the", "caller", "branch", "delay", "slot", "then", "we", "dont", "generate", "the", "instruction", "prefetch", "instruction", ".", "Scan", "up", "to", "32", "instructions", "after", "the", "call", "and", "checks", "for", "the", "JUMP", "and", "call", "instruction", ".", "If", "there", "is", "a", "call", "or", "JUMP", "instruction", "in", "the", "range", "of", "32", "instruction", "``", "wic", "''", "instruction", "wont", "be", "generated", ".", "Otherwise", "insert", "the", "``", "wic", "''", "instruction", "in", "the", "fall", "through", "of", "the", "call", "instruction", "four", "instruction", "after", "the", "call", ".", "before_4", "is", "used", "for", "the", "position", "to", "insert", "``", "wic", "''", "instructions", ".", "before_16", "is", "used", "to", "check", "for", "call", "and", "JUMP", "instruction", "for", "first", "15", "insns", "." ]

[ "microblaze", "0", "0", "0", "128", "4", "0", "4", "4", "0", "14", "4", "0", "0", "32", "4", "4", "4" ]

[]

[ "<s>", "bool", "XCorePassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createXCoreISelDag", "(", "getXCoreTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

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

[]

[ "<s>", "static", "bool", "nvptx_modes_tieable_p", "(", "machine_mode", ",", "machine_mode", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "void", "mn10300_option_override", "(", "void", ")", "{", "if", "(", "TARGET_AM33", ")", "target_flags", "&=", "~", "MASK_MULT_BUG", ";", "else", "{", "flag_schedule_insns", "=", "0", ";", "flag_schedule_insns_after_reload", "=", "0", ";", "flag_split_wide_types", "=", "1", ";", "}", "if", "(", "mn10300_tune_string", ")", "{", "if", "(", "strcasecmp", "(", "mn10300_tune_string", ",", "\"mn10300\"", ")", "==", "0", ")", "mn10300_tune_cpu", "=", "PROCESSOR_MN10300", ";", "else", "if", "(", "strcasecmp", "(", "mn10300_tune_string", ",", "\"am33\"", ")", "==", "0", ")", "mn10300_tune_cpu", "=", "PROCESSOR_AM33", ";", "else", "if", "(", "strcasecmp", "(", "mn10300_tune_string", ",", "\"am33-2\"", ")", "==", "0", ")", "mn10300_tune_cpu", "=", "PROCESSOR_AM33_2", ";", "else", "if", "(", "strcasecmp", "(", "mn10300_tune_string", ",", "\"am34\"", ")", "==", "0", ")", "mn10300_tune_cpu", "=", "PROCESSOR_AM34", ";", "else", "error", "(", "\"-mtune= expects mn10300, am33, am33-2, or am34\"", ")", ";", "}", "}", "</s>" ]

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

[ "mn10300", "0", "0", "1", "\"mn10300\"", "0", "\"am33\"", "0", "\"am33-2\"", "0", "\"am34\"", "0", "\"-mtune= expects mn10300, am33, am33-2, or am34\"" ]

[]

[ "<s>", "static", "bool", "csky_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "!", "(", "TARGET_HARD_FLOAT", "&&", "mode1", "!=", "mode2", "&&", "(", "mode1", "==", "DFmode", "||", "mode2", "==", "DFmode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", ".", "We", "ca", "n't", "tie", "DFmode", "with", "other", "modes", "when", "V_REGs", "might", "be", "in", "use", "because", "those", "registers", "mess", "with", "the", "stored", "bits", "." ]

[ "csky" ]

[]

[ "<s>", "static", "void", "msp430_evaluate_arg", "(", "cumulative_args_t", "cap", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "cap", ")", ";", "int", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "int", "i", ";", "ca", "->", "reg_count", "=", "0", ";", "ca", "->", "mem_count", "=", "0", ";", "if", "(", "!", "named", ")", "return", ";", "if", "(", "mode", "==", "PSImode", ")", "nregs", "=", "1", ";", "else", "nregs", "=", "(", "nregs", "+", "1", ")", "/", "2", ";", "if", "(", "ca", "->", "special_p", ")", "{", "ca", "->", "start_reg", "=", "8", ";", "ca", "->", "reg_count", "=", "4", ";", "return", ";", "}", "switch", "(", "nregs", ")", "{", "case", "1", ":", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "if", "(", "!", "ca", "->", "reg_used", "[", "i", "]", ")", "{", "ca", "->", "reg_count", "=", "1", ";", "ca", "->", "start_reg", "=", "CA_FIRST_REG", "+", "i", ";", "return", ";", "}", "break", ";", "case", "2", ":", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "if", "(", "!", "ca", "->", "reg_used", "[", "i", "]", "&&", "!", "ca", "->", "reg_used", "[", "i", "+", "1", "]", ")", "{", "ca", "->", "reg_count", "=", "2", ";", "ca", "->", "start_reg", "=", "CA_FIRST_REG", "+", "i", ";", "return", ";", "}", "if", "(", "!", "ca", "->", "reg_used", "[", "3", "]", "&&", "ca", "->", "can_split", ")", "{", "ca", "->", "reg_count", "=", "1", ";", "ca", "->", "mem_count", "=", "2", ";", "ca", "->", "start_reg", "=", "CA_FIRST_REG", "+", "3", ";", "return", ";", "}", "break", ";", "case", "3", ":", "case", "4", ":", "ca", "->", "can_split", "=", "0", ";", "if", "(", "!", "ca", "->", "reg_used", "[", "0", "]", "&&", "!", "ca", "->", "reg_used", "[", "1", "]", "&&", "!", "ca", "->", "reg_used", "[", "2", "]", "&&", "!", "ca", "->", "reg_used", "[", "3", "]", ")", "{", "ca", "->", "reg_count", "=", "4", ";", "ca", "->", "start_reg", "=", "CA_FIRST_REG", ";", "return", ";", "}", "break", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "argument", "passing", ";", "this", "function", "is", "the", "common", "code", "that", "determines", "where", "an", "argument", "will", "be", "passed", "." ]

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

[]

[ "<s>", "void", "PIC16InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "PIC16TargetLowering", "*", "PTLI", "=", "TM", ".", "getTargetLowering", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "createESName", "(", "PAN", "::", "getTempdataLabel", "(", "FuncName", ")", ")", ";", "if", "(", "RC", "==", "PIC16", "::", "GPRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PIC16", "::", "movf", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "1", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "if", "(", "RC", "==", "PIC16", "::", "FSR16RegisterClass", ")", "{", "unsigned", "opcode", "=", "(", "DestReg", "==", "PIC16", "::", "FSR0", ")", "?", "PIC16", "::", "restore_fsr0", ":", "PIC16", "::", "restore_fsr1", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opcode", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "3", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "assert", "(", "0", "&&", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16", "PIC16::GPRRegisterClass", "PIC16::movf", "1", "1", "PIC16::FSR16RegisterClass", "PIC16::FSR0", "PIC16::restore_fsr0", "PIC16::restore_fsr1", "3", "1", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "static", "bool", "nios2_legitimate_address_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "operand", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "operand", ")", ")", "return", "false", ";", "case", "CONST", ":", "if", "(", "gprel_constant_p", "(", "operand", ")", ")", "return", "true", ";", "case", "LABEL_REF", ":", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "false", ";", "case", "REG", ":", "return", "nios2_regno_ok_for_base_p", "(", "REGNO", "(", "operand", ")", ",", "strict_p", ")", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "operand", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operand", ",", "1", ")", ";", "return", "(", "nios2_valid_addr_expr_p", "(", "op0", ",", "op1", ",", "strict_p", ")", "||", "nios2_valid_addr_expr_p", "(", "op1", ",", "op0", ",", "strict_p", ")", ")", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

[ "nios2", "0", "1" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldInsertExtraNopBytesForCodeAlign", "(", "const", "MCAlignFragment", "&", "AF", ",", "unsigned", "&", "Size", ")", "{", "const", "MCSubtargetInfo", "*", "STI", "=", "AF", ".", "getSubtargetInfo", "(", ")", ";", "if", "(", "!", "STI", "->", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "return", "false", ";", "bool", "HasStdExtC", "=", "STI", "->", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "if", "(", "AF", ".", "getAlignment", "(", ")", "<=", "MinNopLen", ")", "{", "return", "false", ";", "}", "else", "{", "Size", "=", "AF", ".", "getAlignment", "(", ")", "-", "MinNopLen", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Hook", "to", "check", "if", "extra", "nop", "bytes", "must", "be", "inserted", "for", "alignment", "directive", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "RISCV::FeatureStdExtC", "2", "4" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DOUT", "<<", "\"FI: \"", "<<", "FrameIndex", "<<", "\" Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DOUT", "<<", "\"Corrected Offset \"", "<<", "Offset", "<<", "\" for stack size: \"", "<<", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", "<<", "\"\\n\"", ";", "if", "(", "Offset", ">", "IMM_HIGH", "||", "Offset", "<", "IMM_LOW", ")", "{", "DOUT", "<<", "\"Unconditionally using R28 for evil purposes Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "Alpha", "::", "R28", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "getLower16", "(", "Offset", ")", ")", ";", "MachineInstr", "*", "nMI", "=", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R28", ")", ".", "addImm", "(", "getUpper16", "(", "Offset", ")", ")", ".", "addReg", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ")", ";", "MBB", ".", "insert", "(", "II", ",", "nMI", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "Alpha", "Alpha", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "Alpha::R15", "Alpha::R30", "\"FI: \"", "\" Offset: \"", "\"\\n\"", "\"Corrected Offset \"", "\" for stack size: \"", "\"\\n\"", "\"Unconditionally using R28 for evil purposes Offset: \"", "\"\\n\"", "1", "Alpha::R28", "Alpha::LDAH", "Alpha::R28", "Alpha::R15", "Alpha::R30" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "core2i7_first_cycle_multipass_begin", "(", "void", "*", "_data", ",", "signed", "char", "*", "ready_try", ",", "int", "n_ready", ",", "bool", "first_cycle_insn_p", ")", "{", "ix86_first_cycle_multipass_data_t", "data", "=", "(", "ix86_first_cycle_multipass_data_t", ")", "_data", ";", "const_ix86_first_cycle_multipass_data_t", "prev_data", "=", "ix86_first_cycle_multipass_data", ";", "data", "->", "ifetch_block_len", "=", "prev_data", "->", "ifetch_block_len", ";", "data", "->", "ifetch_block_n_insns", "=", "prev_data", "->", "ifetch_block_n_insns", ";", "core2i7_first_cycle_multipass_filter_ready_try", "(", "data", ",", "ready_try", ",", "n_ready", ",", "first_cycle_insn_p", ")", ";", "}", "</s>" ]

[ "Prepare", "for", "a", "new", "round", "of", "multipass", "lookahead", "scheduling", "." ]

[ "i386" ]

[]

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

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "UPT", "4" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "HasDebugInfo", "=", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ";", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "if", "(", "auto", "*", "TS", "=", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ")", "{", "if", "(", "HasDebugInfo", ")", "{", "TS", "->", "closeLastSection", "(", ")", ";", "OutStreamer", "->", "emitRawText", "(", "\"\\t.section\\t.debug_loc\\t{\\t}\"", ")", ";", "}", "TS", "->", "outputDwarfFileDirectives", "(", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "\"\\t.section\\t.debug_loc\\t{\\t}\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "STriw", ":", "case", "Hexagon", "::", "STrid", ":", "case", "Hexagon", "::", "STrih", ":", "case", "Hexagon", "::", "STrib", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "default", ":", "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", "." ]

[ "Hexagon", "Hexagon", "Hexagon::STriw", "Hexagon::STrid", "Hexagon::STrih", "Hexagon::STrib", "2", "1", "1", "0", "2", "0", "0" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "MI", ".", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "MI", ".", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "0", ",", "Count", "=", "0", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "++", "Count", ";", "Lat", "=", "std", "::", "max", "(", "Lat", ",", "SchedModel", ".", "computeInstrLatency", "(", "&", "*", "I", ")", ")", ";", "}", "return", "Lat", "+", "Count", "-", "1", ";", "}", "return", "SchedModel", ".", "computeInstrLatency", "(", "&", "MI", ")", ";", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "AMDGPU", "SI", "0", "0", "1" ]

[]

[ "<s>", "uint32_t", "ARM64MCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"Unexpected ADR target type!\"", ")", ";", "MCFixupKind", "Kind", "=", "MI", ".", "getOpcode", "(", ")", "==", "ARM64", "::", "BL", "?", "MCFixupKind", "(", "ARM64", "::", "fixup_arm64_pcrel_call26", ")", ":", "MCFixupKind", "(", "ARM64", "::", "fixup_arm64_pcrel_branch26", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "ARM64", "ARM64", "\"Unexpected ADR target type!\"", "ARM64::BL", "ARM64::fixup_arm64_pcrel_call26", "ARM64::fixup_arm64_pcrel_branch26", "0", "0" ]

[]