Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "nvptx_asm_declare_constant_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const_tree", "exp", ",", "HOST_WIDE_INT", "obj_size", ")", "{", "write_var_marker", "(", "file", ",", "true", ",", "false", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t\"", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "exp", ")", ";", "nvptx_assemble_decl_begin", "(", "file", ",", "name", ",", "\".const\"", ",", "type", ",", "obj_size", ",", "TYPE_ALIGN", "(", "type", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_DECLARE_CONSTANT_NAME", ".", "Begin", "the", "process", "of", "writing", "a", "constant", "variable", "EXP", "with", "NAME", "and", "SIZE", "and", "its", "initializer", "to", "FILE", "." ]

[ "nvptx", "\"\\t\"", "\".const\"" ]

[]

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

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

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

[]

[ "<s>", "void", "fma_forest", "::", "merge_forest", "(", "fma_forest", "*", "other_forest", ")", "{", "std", "::", "list", "<", "fma_root_node", "*", ">", "*", "other_roots", ";", "std", "::", "list", "<", "fma_root_node", "*", ">", "::", "iterator", "other_root_iter", ";", "if", "(", "this", "==", "other_forest", ")", "return", ";", "other_roots", "=", "other_forest", "->", "m_roots", ";", "for", "(", "other_root_iter", "=", "other_roots", "->", "begin", "(", ")", ";", "other_root_iter", "!=", "other_roots", "->", "end", "(", ")", ";", "++", "other_root_iter", ")", "(", "*", "other_root_iter", ")", "->", "set_forest", "(", "this", ")", ";", "this", "->", "m_globals", "->", "remove_forest", "(", "other_forest", ")", ";", "this", "->", "m_roots", "->", "splice", "(", "this", "->", "m_roots", "->", "begin", "(", ")", ",", "*", "other_roots", ")", ";", "this", "->", "m_nb_nodes", "+=", "other_forest", "->", "m_nb_nodes", ";", "delete", "other_forest", ";", "}", "</s>" ]

[ "Merge", "REF_FOREST", "and", "OTHER_FOREST", "together", ",", "making", "REF_FOREST", "the", "canonical", "fma_forest", "object", "to", "represent", "both", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupSetCC", "(", ")", ")", ";", "addPass", "(", "createX86OptimizeLEAs", "(", ")", ")", ";", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "}", "addPass", "(", "createX86WinAllocaExpander", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mips_split_64bit_move_p", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "TARGET_64BIT", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "src", ")", "&&", "FP_REG_RTX_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "mips_isa", ">", "1", ")", "{", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "src", ")", "&&", "MEM_P", "(", "dest", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "64-bit", "move", "from", "SRC", "to", "DEST", "should", "be", "split", "into", "two", "." ]

[ "mips", "1" ]

[]

[ "<s>", "const", "KudeyarTargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "KudeyarTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

[ "Kudeyar", "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "XCoreTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"", "XCore" ]

[]

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

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

[ "tilegx", "0" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "I", "=", "df_begin", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ",", "E", "=", "df_end", "(", "&", "F", ".", "getEntryBlock", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "BranchInst", "*", "Term", "=", "dyn_cast", "<", "BranchInst", ">", "(", "(", "*", "I", ")", "->", "getTerminator", "(", ")", ")", ";", "if", "(", "!", "Term", "||", "Term", "->", "isUnconditional", "(", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "1", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "closeControlFlow", "(", "*", "I", ")", ";", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "*", "I", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "*", "I", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";", "}", "closeControlFlow", "(", "*", "I", ")", ";", "}", "openIf", "(", "Term", ")", ";", "}", "assert", "(", "Stack", ".", "empty", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "SI", "1" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldInsertExtraNopBytesForCodeAlign", "(", "const", "MCAlignFragment", "&", "AF", ",", "unsigned", "&", "Size", ")", "{", "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", "." ]

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

[]

[ "<s>", "void", "emitBytes", "(", "StringRef", "Data", ")", "override", "{", "emitDataMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitBytes", "(", "Data", ")", ";", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before expand-condsets\\n\"", ",", "LIS", "->", "getSlotIndexes", "(", ")", ")", ")", ";", "bool", "Changed", "=", "false", ";", "Changed", "|=", "coalesceSegments", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Changed", "|=", "splitInBlock", "(", "*", "I", ")", ";", "Changed", "|=", "predicateInBlock", "(", "*", "I", ")", ";", "}", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "postprocessUndefImplicitUses", "(", "*", "I", ")", ";", "if", "(", "Changed", ")", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After expand-condsets\\n\"", ",", "LIS", "->", "getSlotIndexes", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"Before expand-condsets\\n\"", "\"After expand-condsets\\n\"" ]

[]

[ "<s>", "unsigned", "MBlazeIntrinsicInfo", "::", "lookupName", "(", "const", "char", "*", "Name", ",", "unsigned", "Len", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "Look", "up", "target", "intrinsic", "by", "name", "." ]

[ "MBlaze", "MBlaze", "0" ]

[]

[ "<s>", "static", "void", "mcore_mark_dllimport", "(", "tree", "decl", ")", "{", "const", "char", "*", "oldname", ";", "char", "*", "newname", ";", "tree", "idp", ";", "rtx", "rtlname", ";", "rtx", "newrtl", ";", "rtlname", "=", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "rtlname", ")", "==", "MEM", ")", "rtlname", "=", "XEXP", "(", "rtlname", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "rtlname", ")", "==", "SYMBOL_REF", ")", ";", "oldname", "=", "XSTR", "(", "rtlname", ",", "0", ")", ";", "gcc_assert", "(", "!", "mcore_dllexport_name_p", "(", "oldname", ")", ")", ";", "if", "(", "mcore_dllimport_name_p", "(", "oldname", ")", ")", "return", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "!", "DECL_VIRTUAL_P", "(", "decl", ")", "&&", "DECL_INITIAL", "(", "decl", ")", ")", "{", "error", "(", "\"initialized variable %q+D is marked dllimport\"", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "!", "DECL_VIRTUAL_P", "(", "decl", ")", ")", "{", "DECL_EXTERNAL", "(", "decl", ")", "=", "1", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "}", "newname", "=", "alloca", "(", "strlen", "(", "oldname", ")", "+", "11", ")", ";", "sprintf", "(", "newname", ",", "\"@i.__imp_%s\"", ",", "oldname", ")", ";", "idp", "=", "get_identifier", "(", "newname", ")", ";", "newrtl", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "IDENTIFIER_POINTER", "(", "idp", ")", ")", ")", ";", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", "=", "newrtl", ";", "}", "</s>" ]

[ "Mark", "a", "DECL", "as", "being", "dllimport", "'d", "." ]

[ "mcore", "0", "0", "0", "\"initialized variable %q+D is marked dllimport\"", "1", "1", "11", "\"@i.__imp_%s\"", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SITargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", "==", "\"r\"", ")", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled type for 'r' inline asm constraint\"", ")", ";", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "case", "MVT", "::", "i32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ";", "}", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "1", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", "[", "1", "]", "==", "'v'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'s'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "}", "if", "(", "RC", ")", "{", "uint32_t", "Idx", ";", "bool", "Failed", "=", "Constraint", ".", "substr", "(", "2", ")", ".", "getAsInteger", "(", "10", ",", "Idx", ")", ";", "if", "(", "!", "Failed", "&&", "Idx", "<", "RC", "->", "getNumRegs", "(", ")", ")", "return", "std", "::", "make_pair", "(", "RC", "->", "getRegister", "(", "Idx", ")", ",", "RC", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"r\"", "\"Unhandled type for 'r' inline asm constraint\"", "MVT::i64", "0U", "AMDGPU::SGPR_64RegClass", "MVT::i32", "0U", "AMDGPU::SGPR_32RegClass", "1", "1", "AMDGPU::VGPR_32RegClass", "1", "AMDGPU::SGPR_32RegClass", "2", "10" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "TargetTransformInfo", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "HexagonEarlyIfConversion", "::", "isValid", "(", "const", "FlowPattern", "&", "FP", ")", "const", "{", "if", "(", "hasEHLabel", "(", "FP", ".", "SplitB", ")", ")", "return", "false", ";", "if", "(", "FP", ".", "TrueB", "&&", "!", "isValidCandidate", "(", "FP", ".", "TrueB", ")", ")", "return", "false", ";", "if", "(", "FP", ".", "FalseB", "&&", "!", "isValidCandidate", "(", "FP", ".", "FalseB", ")", ")", "return", "false", ";", "if", "(", "FP", ".", "JoinB", ")", "{", "const", "MachineBasicBlock", "&", "B", "=", "*", "FP", ".", "JoinB", ";", "for", "(", "auto", "&", "MI", ":", "B", ")", "{", "if", "(", "!", "MI", ".", "isPHI", "(", ")", ")", "break", ";", "if", "(", "usesUndefVReg", "(", "&", "MI", ")", ")", "return", "false", ";", "unsigned", "DefR", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", "->", "getRegClass", "(", "DefR", ")", ";", "if", "(", "RC", "==", "&", "Hexagon", "::", "PredRegsRegClass", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon::PredRegsRegClass" ]

[]

[ "<s>", "bool", "XCoreDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Reg", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "return", "true", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "true", ";", "case", "XCoreISD", "::", "CPRelativeWrapper", ":", "Reg", "=", "CurDAG", "->", "getRegister", "(", "XCore", "::", "CP", ",", "MVT", "::", "i32", ")", ";", "break", ";", "case", "XCoreISD", "::", "DPRelativeWrapper", ":", "Reg", "=", "CurDAG", "->", "getRegister", "(", "XCore", "::", "DP", ",", "MVT", "::", "i32", ")", ";", "break", ";", "}", "}", "OutOps", ".", "push_back", "(", "Reg", ")", ";", "OutOps", ".", "push_back", "(", "Op", ".", "getOperand", "(", "0", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "XCore", "XCore", "XCoreISD::CPRelativeWrapper", "XCore::CP", "MVT::i32", "XCoreISD::DPRelativeWrapper", "XCore::DP", "MVT::i32", "0" ]

[]

[ "<s>", "static", "void", "union_uses", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ",", "df_ref", "def", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_out", "=", "1", ";", "while", "(", "link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_out", "=", "1", ";", "if", "(", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "{", "rtx", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "(", "void", ")", "unionfind_union", "(", "insn_entry", "+", "INSN_UID", "(", "insn", ")", ",", "insn_entry", "+", "INSN_UID", "(", "use_insn", ")", ")", ";", "}", "link", "=", "link", "->", "next", ";", "}", "}", "</s>" ]

[ "Union", "INSN", "with", "all", "insns", "containing", "uses", "reached", "from", "DEF", ".", "Detect", "whether", "DEF", "is", "live-out", "from", "the", "current", "function", "." ]

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

[]

[ "<s>", "bool", "X86AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "static", "const", "char", "Nops", "[", "10", "]", "[", "11", "]", "=", "{", "\"\\x90\"", ",", "\"\\x66\\x90\"", ",", "\"\\x0f\\x1f\\x00\"", ",", "\"\\x0f\\x1f\\x40\\x00\"", ",", "\"\\x0f\\x1f\\x44\\x00\\x00\"", ",", "\"\\x66\\x0f\\x1f\\x44\\x00\\x00\"", ",", "\"\\x0f\\x1f\\x80\\x00\\x00\\x00\\x00\"", ",", "\"\\x0f\\x1f\\x84\\x00\\x00\\x00\\x00\\x00\"", ",", "\"\\x66\\x0f\\x1f\\x84\\x00\\x00\\x00\\x00\\x00\"", ",", "\"\\x66\\x2e\\x0f\\x1f\\x84\\x00\\x00\\x00\\x00\\x00\"", ",", "}", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureNOPL", "]", ")", "{", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "++", "i", ")", "OS", "<<", "'\\x90'", ";", "return", "true", ";", "}", "uint64_t", "MaxNopLength", "=", "10", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast7ByteNOP", "]", ")", "MaxNopLength", "=", "7", ";", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast15ByteNOP", "]", ")", "MaxNopLength", "=", "15", ";", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast11ByteNOP", "]", ")", "MaxNopLength", "=", "11", ";", "do", "{", "const", "uint8_t", "ThisNopLength", "=", "(", "uint8_t", ")", "std", "::", "min", "(", "Count", ",", "MaxNopLength", ")", ";", "const", "uint8_t", "Prefixes", "=", "ThisNopLength", "<=", "10", "?", "0", ":", "ThisNopLength", "-", "10", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Prefixes", ";", "i", "++", ")", "OS", "<<", "'\\x66'", ";", "const", "uint8_t", "Rest", "=", "ThisNopLength", "-", "Prefixes", ";", "if", "(", "Rest", "!=", "0", ")", "OS", ".", "write", "(", "Nops", "[", "Rest", "-", "1", "]", ",", "Rest", ")", ";", "Count", "-=", "ThisNopLength", ";", "}", "while", "(", "Count", "!=", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "10", "11", "\"\\x90\"", "\"\\x66\\x90\"", "\"\\x0f\\x1f\\x00\"", "\"\\x0f\\x1f\\x40\\x00\"", "\"\\x0f\\x1f\\x44\\x00\\x00\"", "\"\\x66\\x0f\\x1f\\x44\\x00\\x00\"", "\"\\x0f\\x1f\\x80\\x00\\x00\\x00\\x00\"", "\"\\x0f\\x1f\\x84\\x00\\x00\\x00\\x00\\x00\"", "\"\\x66\\x0f\\x1f\\x84\\x00\\x00\\x00\\x00\\x00\"", "\"\\x66\\x2e\\x0f\\x1f\\x84\\x00\\x00\\x00\\x00\\x00\"", "X86::FeatureNOPL", "0", "10", "X86::FeatureFast7ByteNOP", "7", "X86::FeatureFast15ByteNOP", "15", "X86::FeatureFast11ByteNOP", "11", "10", "0", "10", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "rtx", "nds32_read_argument", "(", "tree", "exp", ",", "unsigned", "int", "index", ")", "{", "return", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "index", ")", ")", ";", "}", "</s>" ]

[ "Read", "the", "requested", "argument", "from", "the", "EXP", "given", "by", "INDEX", ".", "Return", "the", "value", "as", "an", "rtx", "." ]

[ "nds32" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SystemZ Instruction Shortening\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ Instruction Shortening\"" ]

[]

[ "<s>", "static", "rtx", "arc_call_tls_get_addr", "(", "rtx", "ti", ")", "{", "rtx", "arg", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "rtx", "ret", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "rtx", "fn", ";", "rtx_insn", "*", "insn", ";", "if", "(", "!", "arc_tls_symbol", ")", "arc_tls_symbol", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "emit_move_insn", "(", "arg", ",", "ti", ")", ";", "fn", "=", "gen_rtx_MEM", "(", "SImode", ",", "arc_tls_symbol", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_call_value", "(", "ret", ",", "fn", ",", "const0_rtx", ")", ")", ";", "RTL_CONST_CALL_P", "(", "insn", ")", "=", "1", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "ret", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "arg", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Emit", "a", "call", "to", "__tls_get_addr", ".", "TI", "is", "the", "argument", "to", "this", "function", ".", "RET", "is", "an", "RTX", "for", "the", "return", "value", "location", ".", "The", "entire", "insn", "sequence", "is", "returned", "." ]

[ "arc", "\"__tls_get_addr\"", "1" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "addPass", "(", "createAArch64BranchRelaxation", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "nullptr", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "processBlock", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "IA", ":", "BA", ".", "Addr", "->", "members", "(", "*", "DFG", ")", ")", "{", "if", "(", "!", "DFG", "->", "IsCode", "<", "NodeAttrs", "::", "Stmt", ">", "(", "IA", ")", ")", "continue", ";", "NodeAddr", "<", "StmtNode", "*", ">", "SA", "=", "IA", ";", "MachineInstr", "*", "MI", "=", "SA", ".", "Addr", "->", "getCode", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "Hexagon", "::", "A2_tfrsi", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isGlobal", "(", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Analyzing \"", "<<", "HII", "->", "getName", "(", "MI", "->", "getOpcode", "(", ")", ")", "<<", "\"]: \"", "<<", "*", "MI", "<<", "\"\\n\\t[InstrNode]: \"", "<<", "Print", "<", "NodeAddr", "<", "InstrNode", "*", ">>", "(", "IA", ",", "*", "DFG", ")", "<<", "'\\n'", ")", ";", "NodeList", "UNodeList", ";", "getAllRealUses", "(", "SA", ",", "UNodeList", ")", ";", "if", "(", "!", "allValidCandidates", "(", "SA", ",", "UNodeList", ")", ")", "continue", ";", "short", "SizeInc", "=", "0", ";", "unsigned", "DefR", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "InstrEvalMap", "InstrEvalResult", ";", "if", "(", "!", "analyzeUses", "(", "DefR", ",", "UNodeList", ",", "InstrEvalResult", ",", "SizeInc", ")", ")", "continue", ";", "if", "(", "SizeInc", ">", "CodeGrowthLimit", ")", "continue", ";", "bool", "KeepTfr", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[Total reached uses] : \"", "<<", "UNodeList", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[Processing Reached Uses] ===\\n\"", ")", ";", "for", "(", "auto", "I", "=", "UNodeList", ".", "rbegin", "(", ")", ",", "E", "=", "UNodeList", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "NodeAddr", "<", "UseNode", "*", ">", "UseN", "=", "*", "I", ";", "assert", "(", "!", "(", "UseN", ".", "Addr", "->", "getFlags", "(", ")", "&", "NodeAttrs", "::", "PhiRef", ")", "&&", "\"Found a PhiRef node as a real reached use!!\"", ")", ";", "NodeAddr", "<", "StmtNode", "*", ">", "OwnerN", "=", "UseN", ".", "Addr", "->", "getOwner", "(", "*", "DFG", ")", ";", "MachineInstr", "*", "UseMI", "=", "OwnerN", ".", "Addr", "->", "getCode", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t\\t[MI <\"", "<<", "printMBBReference", "(", "*", "UseMI", "->", "getParent", "(", ")", ")", "<<", "\">]: \"", "<<", "*", "UseMI", "<<", "\"\\n\"", ")", ";", "int", "UseMOnum", "=", "-", "1", ";", "unsigned", "NumOperands", "=", "UseMI", "->", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "NumOperands", "-", "1", ";", "++", "j", ")", "{", "const", "MachineOperand", "&", "op", "=", "UseMI", "->", "getOperand", "(", "j", ")", ";", "if", "(", "op", ".", "isReg", "(", ")", "&&", "op", ".", "isUse", "(", ")", "&&", "DefR", "==", "op", ".", "getReg", "(", ")", ")", "UseMOnum", "=", "j", ";", "}", "assert", "(", "UseMOnum", ">=", "0", "&&", "\"Invalid reached use!\"", ")", ";", "if", "(", "InstrEvalResult", "[", "UseMI", "]", ")", "Changed", "|=", "xformUseMI", "(", "MI", ",", "UseMI", ",", "UseN", ",", "UseMOnum", ")", ";", "else", "KeepTfr", "=", "true", ";", "}", "if", "(", "!", "KeepTfr", ")", "Deleted", ".", "insert", "(", "MI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "Hexagon", "Hexagon", "Hexagon::A2_tfrsi", "1", "\"[Analyzing \"", "\"]: \"", "\"\\n\\t[InstrNode]: \"", "0", "0", "\"\\t[Total reached uses] : \"", "\"\\n\"", "\"\\t[Processing Reached Uses] ===\\n\"", "\"Found a PhiRef node as a real reached use!!\"", "\"\\t\\t[MI <\"", "\">]: \"", "\"\\n\"", "1", "0", "1", "0", "\"Invalid reached use!\"" ]

[]

[ "<s>", "Align", "getAlign", "(", "DataLayout", "const", "&", "DL", ",", "const", "GlobalVariable", "*", "GV", ")", "{", "return", "DL", ".", "getValueOrABITypeAlignment", "(", "GV", "->", "getPointerAlignment", "(", "DL", ")", ",", "GV", "->", "getValueType", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "minimum", "known", "alignment", "in", "bytes", "of", "the", "actual", "memory", "reference", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "int", "xtensa_expand_block_move", "(", "rtx", "*", "operands", ")", "{", "static", "const", "machine_mode", "mode_from_align", "[", "]", "=", "{", "VOIDmode", ",", "QImode", ",", "HImode", ",", "VOIDmode", ",", "SImode", ",", "}", ";", "rtx", "dst_mem", "=", "operands", "[", "0", "]", ";", "rtx", "src_mem", "=", "operands", "[", "1", "]", ";", "HOST_WIDE_INT", "bytes", ",", "align", ";", "int", "num_pieces", ",", "move_ratio", ";", "rtx", "temp", "[", "2", "]", ";", "machine_mode", "mode", "[", "2", "]", ";", "int", "amount", "[", "2", "]", ";", "bool", "active", "[", "2", "]", ";", "int", "phase", "=", "0", ";", "int", "next", ";", "int", "offset_ld", "=", "0", ";", "int", "offset_st", "=", "0", ";", "rtx", "x", ";", "if", "(", "!", "optimize", "||", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", ")", "return", "0", ";", "bytes", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "if", "(", "bytes", "<=", "0", ")", "return", "0", ";", "if", "(", "align", ">", "MOVE_MAX", ")", "align", "=", "MOVE_MAX", ";", "move_ratio", "=", "4", ";", "if", "(", "optimize", ">", "2", ")", "move_ratio", "=", "LARGEST_MOVE_RATIO", ";", "num_pieces", "=", "(", "bytes", "/", "align", ")", "+", "(", "bytes", "%", "align", ")", ";", "if", "(", "num_pieces", ">", "move_ratio", ")", "return", "0", ";", "x", "=", "XEXP", "(", "dst_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "dst_mem", "=", "replace_equiv_address", "(", "dst_mem", ",", "x", ")", ";", "}", "x", "=", "XEXP", "(", "src_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "src_mem", "=", "replace_equiv_address", "(", "src_mem", ",", "x", ")", ";", "}", "active", "[", "0", "]", "=", "active", "[", "1", "]", "=", "false", ";", "do", "{", "next", "=", "phase", ";", "phase", "^=", "1", ";", "if", "(", "bytes", ">", "0", ")", "{", "int", "next_amount", ";", "next_amount", "=", "(", "bytes", ">=", "4", "?", "4", ":", "(", "bytes", ">=", "2", "?", "2", ":", "1", ")", ")", ";", "next_amount", "=", "MIN", "(", "next_amount", ",", "align", ")", ";", "amount", "[", "next", "]", "=", "next_amount", ";", "mode", "[", "next", "]", "=", "mode_from_align", "[", "next_amount", "]", ";", "temp", "[", "next", "]", "=", "gen_reg_rtx", "(", "mode", "[", "next", "]", ")", ";", "x", "=", "adjust_address", "(", "src_mem", ",", "mode", "[", "next", "]", ",", "offset_ld", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", "[", "next", "]", ",", "x", ")", ")", ";", "offset_ld", "+=", "next_amount", ";", "bytes", "-=", "next_amount", ";", "active", "[", "next", "]", "=", "true", ";", "}", "if", "(", "active", "[", "phase", "]", ")", "{", "active", "[", "phase", "]", "=", "false", ";", "x", "=", "adjust_address", "(", "dst_mem", ",", "mode", "[", "phase", "]", ",", "offset_st", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x", ",", "temp", "[", "phase", "]", ")", ")", ";", "offset_st", "+=", "amount", "[", "phase", "]", ";", "}", "}", "while", "(", "active", "[", "next", "]", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Try", "to", "expand", "a", "block", "move", "operation", "to", "an", "RTL", "block", "move", "instruction", ".", "If", "not", "optimizing", "or", "if", "the", "block", "size", "is", "not", "a", "constant", "or", "if", "the", "block", "is", "small", ",", "the", "expansion", "fails", "and", "GCC", "falls", "back", "to", "calling", "memcpy", "(", ")", ".", "operands", "[", "0", "]", "is", "the", "destination", "operands", "[", "1", "]", "is", "the", "source", "operands", "[", "2", "]", "is", "the", "length", "operands", "[", "3", "]", "is", "the", "alignment" ]

[ "xtensa", "0", "1", "2", "2", "2", "2", "0", "0", "0", "2", "0", "2", "3", "0", "0", "4", "2", "0", "0", "0", "0", "1", "1", "0", "4", "4", "2", "2", "1", "1" ]

[]

[ "<s>", "static", "int", "translate_unix", "(", "char", "*", "name", ",", "int", "type", "ATTRIBUTE_UNUSED", ")", "{", "strcpy", "(", "filename_buff", ",", "name", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Action", "routine", "called", "by", "decc", "$", "to_vms", ".", "NAME", "is", "a", "file", "name", "or", "directory", "name", ".", "TYPE", "is", "unused", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "{", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "STRH", ":", "case", "ARM", "::", "STRBi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "t2STRi8", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VSTRS", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "tLDRspi", ":", "break", ";", "default", ":", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "8", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "FPOffset", "-=", "80", ";", "Offset", "+=", "MFI", ".", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "!", "(", "(", "MFI", ".", "getLocalFrameMaxAlign", "(", ")", ">", "TFI", "->", "getStackAlign", "(", ")", ")", "&&", "canRealignStack", "(", "MF", ")", ")", ")", "{", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "getFrameRegister", "(", "MF", ")", ",", "FPOffset", ")", ")", "return", "false", ";", "}", "if", "(", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "ARM", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARM::LDRi12", "ARM::LDRH", "ARM::LDRBi12", "ARM::STRi12", "ARM::STRH", "ARM::STRBi12", "ARM::t2LDRi12", "ARM::t2LDRi8", "ARM::t2STRi12", "ARM::t2STRi8", "ARM::VLDRS", "ARM::VLDRD", "ARM::VSTRS", "ARM::VSTRD", "ARM::tSTRspi", "ARM::tLDRspi", "ARM", "ARM", "ARM", "8", "80", "128", "ARM::SP" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "getReturnCC", "(", "CallConv", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "OutVal", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f32", ")", ";", "SDValue", "Undef", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "DL", ",", "MVT", "::", "i64", ")", ",", "0", ")", ";", "SDValue", "Sub_f32", "=", "DAG", ".", "getTargetConstant", "(", "VE", "::", "sub_f32", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "OutVal", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "INSERT_SUBREG", ",", "DL", ",", "MVT", "::", "i64", ",", "Undef", ",", "OutVal", ",", "Sub_f32", ")", ",", "0", ")", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "}", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "\"Unexpected custom lowering\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVal", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "VEISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "ISD::OutputArg", "16", "4", "1", "0", "\"Can only return in registers!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "MVT::i64", "MVT::f32", "MVT::i64", "0", "VE::sub_f32", "MVT::i32", "MVT::i64", "0", "\"Unknown loc info!\"", "\"Unexpected custom lowering\"", "1", "0", "VEISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "WebAssemblyTTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "const", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "return", "TargetTransformInfo", "::", "PSK_FastHardware", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "WebAssembly", "WebAssembly", "\"Ty width must be power of 2\"" ]

[]

[ "<s>", "static", "rtx", "single_set_and_flags", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "multiple_sets", "(", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "XVECLEN", "(", "pat", ",", "0", ")", "==", "2", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "REG_P", "(", "SET_DEST", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ")", "&&", "REGNO", "(", "SET_DEST", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ")", "==", "FLAGS_REGNUM", ")", "return", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ";", "}", "return", "single_set", "(", "insn", ")", ";", "}", "</s>" ]

[ "Wrapper", "around", "single_set", "which", "returns", "the", "first", "SET", "of", "a", "pair", "if", "the", "second", "SET", "is", "to", "the", "flags", "register", "." ]

[ "visium", "0", "2", "0", "0", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "inline", "int", "rs6000_secondary_reload_toc_costs", "(", "addr_mask_type", "addr_mask", ")", "{", "int", "ret", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_SMALL", ")", "ret", "=", "(", "(", "addr_mask", "&", "RELOAD_REG_OFFSET", ")", "==", "0", ")", "?", "1", ":", "2", ";", "else", "ret", "=", "(", "TARGET_MINIMAL_TOC", ")", "?", "6", ":", "3", ";", "return", "ret", ";", "}", "</s>" ]

[ "Helper", "function", "to", "return", "the", "cost", "of", "adding", "a", "TOC", "entry", "address", "." ]

[ "powerpcspe", "0", "1", "2", "6", "3" ]

[]

[ "<s>", "static", "bool", "s390_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fundecl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "OFFSET_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", ")", "return", "int_size_in_bytes", "(", "type", ")", ">", "8", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "return", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "return", "values", "of", "type", "TYPE", "should", "be", "returned", "in", "a", "memory", "buffer", "whose", "address", "is", "passed", "by", "the", "caller", "as", "hidden", "first", "argument", "." ]

[ "s390", "8" ]

[]

[ "<s>", "const", "AMDGPURegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "R600" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "return", ";", "}", "if", "(", "TII", "->", "isMIMG", "(", "MI", ")", ")", "{", "unsigned", "VReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "VReg", ")", ";", "if", "(", "RC", "!=", "&", "AMDGPU", "::", "VReg_128RegClass", ")", "return", ";", "unsigned", "DmaskIdx", "=", "MI", ".", "getNumOperands", "(", ")", "==", "12", "?", "3", ":", "4", ";", "unsigned", "Writemask", "=", "MI", ".", "getOperand", "(", "DmaskIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", ".", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "return", ";", "}", "if", "(", "(", "Node", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "isMachineOpcode", "(", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "EXTRACT_SUBREG", "&&", "!", "Node", "->", "use_begin", "(", ")", "->", "hasAnyUseOfValue", "(", "0", ")", ")", ")", "{", "unsigned", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "Def", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]

[ "AMDGPU", "SI", "SI", "0", "AMDGPU::VReg_128RegClass", "12", "3", "4", "0", "0", "4", "1", "1", "0", "1", "AMDGPU::VGPR_32RegClass", "2", "AMDGPU::VReg_64RegClass", "3", "AMDGPU::VReg_96RegClass", "AMDGPU::getAtomicNoRetOp", "1", "0", "0", "1", "0", "AMDGPU::EXTRACT_SUBREG", "0", "0", "0", "AMDGPU::IMPLICIT_DEF" ]

[]

[ "<s>", "size_t", "ARMELFAttributeData", "::", "emit", "(", "char", "*", "pBuf", ")", "const", "{", "char", "*", "buffer", "=", "pBuf", ";", "const", "ELFAttributeValue", "&", "attr_conformance", "=", "m_Attrs", "[", "Tag_conformance", "]", ";", "if", "(", "attr_conformance", ".", "shouldEmit", "(", ")", ")", "{", "if", "(", "!", "ELFAttributeData", "::", "WriteAttribute", "(", "Tag_conformance", ",", "attr_conformance", ",", "buffer", ")", ")", "{", "return", "0", ";", "}", "}", "const", "ELFAttributeValue", "&", "attr_nodefaults", "=", "m_Attrs", "[", "Tag_nodefaults", "]", ";", "if", "(", "attr_nodefaults", ".", "shouldEmit", "(", ")", ")", "{", "if", "(", "!", "ELFAttributeData", "::", "WriteAttribute", "(", "Tag_nodefaults", ",", "attr_nodefaults", ",", "buffer", ")", ")", "{", "return", "0", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Tag_nodefaults", ";", "++", "i", ")", "{", "TagType", "tag", "=", "static_cast", "<", "TagType", ">", "(", "i", ")", ";", "const", "ELFAttributeValue", "&", "value", "=", "m_Attrs", "[", "tag", "]", ";", "if", "(", "value", ".", "shouldEmit", "(", ")", "&&", "!", "ELFAttributeData", "::", "WriteAttribute", "(", "tag", ",", "value", ",", "buffer", ")", ")", "{", "return", "0", ";", "}", "}", "for", "(", "unsigned", "i", "=", "(", "Tag_nodefaults", "+", "1", ")", ";", "i", "<=", "Tag_Max", ";", "++", "i", ")", "{", "TagType", "tag", "=", "static_cast", "<", "TagType", ">", "(", "i", ")", ";", "const", "ELFAttributeValue", "&", "value", "=", "m_Attrs", "[", "tag", "]", ";", "if", "(", "value", ".", "shouldEmit", "(", ")", "&&", "(", "i", "!=", "Tag_conformance", ")", "&&", "!", "ELFAttributeData", "::", "WriteAttribute", "(", "tag", ",", "value", ",", "buffer", ")", ")", "{", "return", "0", ";", "}", "}", "for", "(", "UnknownAttrsMap", "::", "const_iterator", "unknown_attr_it", "=", "m_UnknownAttrs", ".", "begin", "(", ")", ",", "unknown_attr_end", "=", "m_UnknownAttrs", ".", "end", "(", ")", ";", "unknown_attr_it", "!=", "unknown_attr_end", ";", "++", "unknown_attr_it", ")", "{", "TagType", "tag", "=", "unknown_attr_it", "->", "first", ";", "const", "ELFAttributeValue", "&", "value", "=", "unknown_attr_it", "->", "second", ";", "if", "(", "value", ".", "shouldEmit", "(", ")", "&&", "!", "ELFAttributeData", "::", "WriteAttribute", "(", "tag", ",", "value", ",", "buffer", ")", ")", "{", "return", "0", ";", "}", "}", "return", "(", "buffer", "-", "pBuf", ")", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

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

[]

[ "<s>", "static", "bool", "Check", "(", "DecodeStatus", "&", "Out", ",", "DecodeStatus", "In", ")", "{", "switch", "(", "In", ")", "{", "case", "MCDisassembler", "::", "Success", ":", "return", "true", ";", "case", "MCDisassembler", "::", "SoftFail", ":", "Out", "=", "In", ";", "return", "true", ";", "case", "MCDisassembler", "::", "Fail", ":", "Out", "=", "In", ";", "return", "false", ";", "}", "llvm_unreachable", "(", "\"Invalid DecodeStatus!\"", ")", ";", "}", "</s>" ]

[ "Matches", "check", "string", "and", "its", "``", "not", "strings", "''", "and/or", "``", "dag", "strings", "''", "." ]

[ "ARM", "\"Invalid DecodeStatus!\"" ]

[]

[ "<s>", "static", "rtx", "s390_function_and_libcall_value", "(", "machine_mode", "mode", ",", "const_tree", "ret_type", ",", "const_tree", "fntype_or_decl", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "ret_type", ")", "{", "int", "unsignedp", "=", "TYPE_UNSIGNED", "(", "ret_type", ")", ";", "mode", "=", "promote_function_mode", "(", "ret_type", ",", "mode", ",", "&", "unsignedp", ",", "fntype_or_decl", ",", "1", ")", ";", "}", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "8", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "16", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_LONG", "||", "UNITS_PER_LONG", "==", "UNITS_PER_WORD", ")", "return", "gen_rtx_REG", "(", "mode", ",", "2", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "2", "*", "UNITS_PER_LONG", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "2", ")", ",", "const0_rtx", ")", ";", "RTVEC_ELT", "(", "p", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "3", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "p", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "return", "a", "(", "scalar", ")", "value", "of", "type", "RET_TYPE", ".", "If", "RET_TYPE", "is", "null", ",", "define", "where", "to", "return", "a", "(", "scalar", ")", "value", "of", "mode", "MODE", "from", "a", "libcall", "." ]

[ "s390", "1", "8", "16", "2", "2", "2", "0", "2", "1", "3", "4" ]

[]

[ "<s>", "const", "char", "*", "Z80oldTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "Z80oldISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "Z80oldISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "Z80oldISD", "::", "Wrapper", ":", "return", "\"Z80oldISD::Wrapper\"", ";", "case", "Z80oldISD", "::", "RLC", ":", "return", "\"Z80oldISD::RLC\"", ";", "case", "Z80oldISD", "::", "RRC", ":", "return", "\"Z80oldISD::RRC\"", ";", "case", "Z80oldISD", "::", "RL", ":", "return", "\"Z80oldISD::RL\"", ";", "case", "Z80oldISD", "::", "RR", ":", "return", "\"Z80oldISD::RR\"", ";", "case", "Z80oldISD", "::", "SLA", ":", "return", "\"Z80oldISD::SLA\"", ";", "case", "Z80oldISD", "::", "SRA", ":", "return", "\"Z80oldISD::SRA\"", ";", "case", "Z80oldISD", "::", "SRL", ":", "return", "\"Z80oldISD::SRL\"", ";", "case", "Z80oldISD", "::", "INC", ":", "return", "\"Z80oldISD::INC\"", ";", "case", "Z80oldISD", "::", "DEC", ":", "return", "\"Z80oldISD::DEC\"", ";", "case", "Z80oldISD", "::", "ADD", ":", "return", "\"Z80oldISD::ADD\"", ";", "case", "Z80oldISD", "::", "ADC", ":", "return", "\"Z80oldISD::ADC\"", ";", "case", "Z80oldISD", "::", "SUB", ":", "return", "\"Z80oldISD::SUB\"", ";", "case", "Z80oldISD", "::", "SBC", ":", "return", "\"Z80oldISD::SBC\"", ";", "case", "Z80oldISD", "::", "AND", ":", "return", "\"Z80oldISD::AND\"", ";", "case", "Z80oldISD", "::", "XOR", ":", "return", "\"Z80oldISD::XOR\"", ";", "case", "Z80oldISD", "::", "OR", ":", "return", "\"Z80oldISD::OR\"", ";", "case", "Z80oldISD", "::", "CP", ":", "return", "\"Z80oldISD::CP\"", ";", "case", "Z80oldISD", "::", "TST", ":", "return", "\"Z80oldISD::TST\"", ";", "case", "Z80oldISD", "::", "MLT", ":", "return", "\"Z80oldISD::MLT\"", ";", "case", "Z80oldISD", "::", "SEXT", ":", "return", "\"Z80oldISD::SEXT\"", ";", "case", "Z80oldISD", "::", "CALL", ":", "return", "\"Z80oldISD::CALL\"", ";", "case", "Z80oldISD", "::", "RET_FLAG", ":", "return", "\"Z80oldISD::RET_FLAG\"", ";", "case", "Z80oldISD", "::", "RETN_FLAG", ":", "return", "\"Z80oldISD::RETN_FLAG\"", ";", "case", "Z80oldISD", "::", "RETI_FLAG", ":", "return", "\"Z80oldISD::RETI_FLAG\"", ";", "case", "Z80oldISD", "::", "TC_RETURN", ":", "return", "\"Z80oldISD::TC_RETURN\"", ";", "case", "Z80oldISD", "::", "BRCOND", ":", "return", "\"Z80oldISD::BRCOND\"", ";", "case", "Z80oldISD", "::", "SELECT", ":", "return", "\"Z80oldISD::SELECT\"", ";", "case", "Z80oldISD", "::", "POP", ":", "return", "\"Z80oldISD::POP\"", ";", "case", "Z80oldISD", "::", "PUSH", ":", "return", "\"Z80oldISD::PUSH\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "Z80oldISD::NodeType", "Z80oldISD::FIRST_NUMBER", "Z80oldISD::Wrapper", "\"Z80oldISD::Wrapper\"", "Z80oldISD::RLC", "\"Z80oldISD::RLC\"", "Z80oldISD::RRC", "\"Z80oldISD::RRC\"", "Z80oldISD::RL", "\"Z80oldISD::RL\"", "Z80oldISD::RR", "\"Z80oldISD::RR\"", "Z80oldISD::SLA", "\"Z80oldISD::SLA\"", "Z80oldISD::SRA", "\"Z80oldISD::SRA\"", "Z80oldISD::SRL", "\"Z80oldISD::SRL\"", "Z80oldISD::INC", "\"Z80oldISD::INC\"", "Z80oldISD::DEC", "\"Z80oldISD::DEC\"", "Z80oldISD::ADD", "\"Z80oldISD::ADD\"", "Z80oldISD::ADC", "\"Z80oldISD::ADC\"", "Z80oldISD::SUB", "\"Z80oldISD::SUB\"", "Z80oldISD::SBC", "\"Z80oldISD::SBC\"", "Z80oldISD::AND", "\"Z80oldISD::AND\"", "Z80oldISD::XOR", "\"Z80oldISD::XOR\"", "Z80oldISD::OR", "\"Z80oldISD::OR\"", "Z80oldISD::CP", "\"Z80oldISD::CP\"", "Z80oldISD::TST", "\"Z80oldISD::TST\"", "Z80oldISD::MLT", "\"Z80oldISD::MLT\"", "Z80oldISD::SEXT", "\"Z80oldISD::SEXT\"", "Z80oldISD::CALL", "\"Z80oldISD::CALL\"", "Z80oldISD::RET_FLAG", "\"Z80oldISD::RET_FLAG\"", "Z80oldISD::RETN_FLAG", "\"Z80oldISD::RETN_FLAG\"", "Z80oldISD::RETI_FLAG", "\"Z80oldISD::RETI_FLAG\"", "Z80oldISD::TC_RETURN", "\"Z80oldISD::TC_RETURN\"", "Z80oldISD::BRCOND", "\"Z80oldISD::BRCOND\"", "Z80oldISD::SELECT", "\"Z80oldISD::SELECT\"", "Z80oldISD::POP", "\"Z80oldISD::POP\"", "Z80oldISD::PUSH", "\"Z80oldISD::PUSH\"" ]

[]

[ "<s>", "bool", "find", "(", "const", "SPIRV", "::", "SpecialTypeDescriptor", "&", "TD", ",", "const", "MachineFunction", "*", "MF", ",", "Register", "&", "R", ")", "{", "return", "ST", ".", "find", "(", "TD", ",", "MF", ",", "R", ")", ";", "}", "</s>" ]

[ "Search", "for", "the", "first", "string", "Str", "in", "the", "string", "." ]

[ "SPIRV", "SPIRV::SpecialTypeDescriptor" ]

[]

[ "<s>", "param_iterator", "arg_begin", "(", ")", "const", "{", "return", "ArgumentParams", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "iterator", "pointing", "to", "the", "beginning", "of", "the", "argument", "list", "." ]

[ "HSAIL" ]

[]

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

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

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

[]

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

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

[ "RI5CY" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "R600RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", ")", "const", "{", "return", "&", "CalleeSavedReg", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600" ]

[]

[ "<s>", "bool", "AArch64LegalizerInfo", "::", "legalizeCustom", "(", "LegalizerHelper", "&", "Helper", ",", "MachineInstr", "&", "MI", ")", "const", "{", "MachineIRBuilder", "&", "MIRBuilder", "=", "Helper", ".", "MIRBuilder", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "MIRBuilder", ".", "getMRI", "(", ")", ";", "GISelChangeObserver", "&", "Observer", "=", "Helper", ".", "Observer", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_VAARG", ":", "return", "legalizeVaArg", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "legalizeLoadStore", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "legalizeShlAshrLshr", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeSmallCMGlobalValue", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "legalizeVectorTrunc", "(", "MI", ",", "Helper", ")", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AArch64", "AArch64", "\"expected switch to return\"" ]

[]

[ "<s>", "void", "TOYInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "'$'", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY" ]

[]

[ "<s>", "void", "AMDGPUTargetELFStreamer", "::", "finish", "(", ")", "{", "std", "::", "string", "Blob", ";", "const", "char", "*", "Vendor", "=", "getPALMetadata", "(", ")", "->", "getVendor", "(", ")", ";", "unsigned", "Type", "=", "getPALMetadata", "(", ")", "->", "getType", "(", ")", ";", "getPALMetadata", "(", ")", "->", "toBlob", "(", "Type", ",", "Blob", ")", ";", "if", "(", "Blob", ".", "empty", "(", ")", ")", "return", ";", "EmitNote", "(", "Vendor", ",", "MCConstantExpr", "::", "create", "(", "Blob", ".", "size", "(", ")", ",", "getContext", "(", ")", ")", ",", "Type", ",", "[", "&", "]", "(", "MCELFStreamer", "&", "OS", ")", "{", "OS", ".", "emitBytes", "(", "Blob", ")", ";", "}", ")", ";", "getPALMetadata", "(", ")", "->", "reset", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "std", "::", "string", "HSAILIntrinsicInfo", "::", "getName", "(", "unsigned", "int", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "int", "numTys", ")", "const", "{", "static", "const", "char", "*", "const", "names", "[", "]", "=", "{", "}", ";", "if", "(", "IntrID", "<", "Intrinsic", "::", "num_intrinsics", ")", "{", "return", "0", ";", "}", "assert", "(", "IntrID", "<", "HSAILIntrinsic", "::", "num_HSAIL_intrinsics", "&&", "\"Invalid intrinsic ID\"", ")", ";", "std", "::", "string", "Result", "(", "names", "[", "IntrID", "-", "Intrinsic", "::", "num_intrinsics", "]", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "HSAIL", "HSAIL", "Intrinsic::num_intrinsics", "0", "HSAILIntrinsic::num_HSAIL_intrinsics", "\"Invalid intrinsic ID\"", "Intrinsic::num_intrinsics" ]

[]

[ "<s>", "bool", "MipsConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "MCP", "=", "mf", ".", "getConstantPool", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island machine function \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", "||", "!", "MipsSubtarget", "::", "useConstantIslands", "(", ")", ")", "{", "return", "false", ";", "}", "TII", "=", "(", "const", "MipsInstrInfo", "*", ")", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MFI", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island processing \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "PrescannedForConstants", ")", "prescanForConstants", "(", ")", ";", "HasFarJump", "=", "false", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "(", "void", ")", "NoBRIters", ";", "while", "(", "true", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning CP iteration #\"", "<<", "NoCPIters", "<<", "'\\n'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "report_fatal_error", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning BR iteration #\"", "<<", "NoBRIters", "<<", "'\\n'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "report_fatal_error", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BBInfo", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"constant island machine function \"", "\"\\n\"", "Mips", "Mips", "Mips", "Mips", "Mips", "\"constant island processing \"", "\"\\n\"", "0", "0", "\"Beginning CP iteration #\"", "0", "30", "\"Constant Island pass failed to converge!\"", "\"Beginning BR iteration #\"", "0", "30", "\"Branch Fix Up pass failed to converge!\"" ]

[]

[ "<s>", "bool", "function_resolver", "::", "require_vector_or_scalar_type", "(", "unsigned", "int", "argno", ")", "{", "tree", "actual", "=", "get_argument_type", "(", "argno", ")", ";", "if", "(", "actual", "==", "error_mark_node", ")", "return", "false", ";", "if", "(", "!", "scalar_argument_p", "(", "argno", ")", "&&", "!", "VECTOR_TYPE_P", "(", "actual", ")", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector or scalar type\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "vector", "or", "scalar", "argument", ".", "Return", "true", "if", "it", "is", ",", "otherwise", "report", "an", "appropriate", "error", "." ]

[ "aarch64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector or scalar type\"", "1" ]

[]

[ "<s>", "void", "HSAILFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DenseMap", "<", "int", ",", "uint64_t", ">", "SpillMap", ";", "DenseMap", "<", "int", ",", "uint64_t", ">", "PrivateMap", ";", "int64_t", "SpillSize", "=", "0", ";", "int64_t", "PrivateSize", "=", "0", ";", "unsigned", "SpillAlign", "=", "4", ";", "unsigned", "PrivateAlign", "=", "4", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ",", "E", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "MFI", "->", "isDeadObjectIndex", "(", "I", ")", ")", "continue", ";", "unsigned", "Size", "=", "MFI", "->", "getObjectSize", "(", "I", ")", ";", "unsigned", "Align", "=", "MFI", "->", "getObjectAlignment", "(", "I", ")", ";", "unsigned", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "I", ")", ";", "assert", "(", "Offset", "==", "0", "&&", "\"Stack object offsets should be 0 before frame finalized\"", ")", ";", "if", "(", "MFI", "->", "isSpillSlotObjectIndex", "(", "I", ")", ")", "{", "SpillSize", "=", "(", "SpillSize", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "SpillMap", "[", "I", "]", "=", "SpillSize", ";", "SpillSize", "+=", "Size", ";", "SpillAlign", "=", "std", "::", "max", "(", "SpillAlign", ",", "Align", ")", ";", "}", "else", "{", "PrivateSize", "=", "(", "PrivateSize", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "PrivateMap", "[", "I", "]", "=", "PrivateSize", ";", "PrivateSize", "+=", "Size", ";", "PrivateAlign", "=", "std", "::", "max", "(", "PrivateAlign", ",", "Align", ")", ";", "}", "MFI", "->", "RemoveStackObject", "(", "I", ")", ";", "}", "int", "PrivateIndex", "=", "-", "1", ";", "int", "SpillIndex", "=", "-", "1", ";", "if", "(", "PrivateSize", "!=", "0", ")", "PrivateIndex", "=", "MFI", "->", "CreateStackObject", "(", "PrivateSize", ",", "PrivateAlign", ",", "false", ")", ";", "if", "(", "SpillSize", "!=", "0", ")", "SpillIndex", "=", "MFI", "->", "CreateSpillStackObject", "(", "SpillSize", ",", "SpillAlign", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "int", "AddrIdx", "=", "HSAIL", "::", "getNamedOperandIdx", "(", "Opc", ",", "HSAIL", "::", "OpName", "::", "address", ")", ";", "if", "(", "AddrIdx", "==", "-", "1", ")", "{", "continue", ";", "}", "MachineOperand", "&", "Base", "=", "MI", ".", "getOperand", "(", "AddrIdx", ")", ";", "if", "(", "!", "Base", ".", "isFI", "(", ")", ")", "continue", ";", "int", "Index", "=", "Base", ".", "getIndex", "(", ")", ";", "MachineOperand", "&", "Offset", "=", "MI", ".", "getOperand", "(", "AddrIdx", "+", "2", ")", ";", "int64_t", "OrigOffset", "=", "Offset", ".", "getImm", "(", ")", ";", "if", "(", "MFI", "->", "isSpillSlotObjectIndex", "(", "Index", ")", ")", "{", "Base", ".", "setIndex", "(", "SpillIndex", ")", ";", "Offset", ".", "setImm", "(", "SpillMap", "[", "Index", "]", "+", "OrigOffset", ")", ";", "}", "else", "{", "Base", ".", "setIndex", "(", "PrivateIndex", ")", ";", "Offset", ".", "setImm", "(", "PrivateMap", "[", "Index", "]", "+", "OrigOffset", ")", ";", "}", "}", "}", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "0", "0", "4", "4", "0", "\"Stack object offsets should be 0 before frame finalized\"", "1", "1", "1", "1", "0", "0", "HSAIL::getNamedOperandIdx", "HSAIL::OpName", "1", "2" ]

[]

[ "<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx", "insn", ",", "pattern", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "||", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "||", "!", "single_set", "(", "insn", ")", ")", "continue", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", "&&", "SET_DEST", "(", "pattern", ")", "==", "cc0_rtx", "&&", "compare_diff_p", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "COMPARE", ")", "{", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "GET_CODE", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "else", "if", "(", "true_regnum", "(", "SET_SRC", "(", "pattern", ")", ")", ">=", "0", ")", "{", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "SET_SRC", "(", "pattern", ")", "=", "gen_rtx_NEG", "(", "GET_MODE", "(", "SET_SRC", "(", "pattern", ")", ")", ",", "SET_SRC", "(", "pattern", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "</s>" ]

[ "This", "function", "optimizes", "conditional", "jumps", "." ]

[ "avr", "0", "0", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "void", "sh_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fputs", "(", "\"\\t.section .directive, \\\"SM\\\", @progbits, 1\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.asciz \\\"#<SYMEDIT>#\\\\n\\\"\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_ELF", ")", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "TEXT_SECTION_ASM_OP", ")", ";", "else", "data_section", "(", ")", ";", "if", "(", "TARGET_LITTLE_ENDIAN", ")", "fputs", "(", "\"\\t.little\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "!", "TARGET_ELF", ")", "{", "if", "(", "TARGET_SHCOMPACT", ")", "fputs", "(", "\"\\t.mode\\tSHcompact\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_SHMEDIA", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.mode\\tSHmedia\\n\\t.abi\\t%i\\n\"", ",", "TARGET_SHMEDIA64", "?", "64", ":", "32", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "start", "of", "the", "assembler", "file", "." ]

[ "sh", "\"\\t.section .directive, \\\"SM\\\", @progbits, 1\\n\"", "\"\\t.asciz \\\"#<SYMEDIT>#\\\\n\\\"\\n\"", "\"%s\\n\"", "\"\\t.little\\n\"", "\"\\t.mode\\tSHcompact\\n\"", "\"\\t.mode\\tSHmedia\\n\\t.abi\\t%i\\n\"", "64", "32" ]

[]

[ "<s>", "static", "bool", "rs6000_expand_vec_perm_const_1", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "unsigned", "char", "perm0", ",", "unsigned", "char", "perm1", ")", "{", "rtx", "x", ";", "if", "(", "(", "perm0", "&", "2", ")", "==", "(", "perm1", "&", "2", ")", ")", "{", "if", "(", "perm0", "&", "2", ")", "op0", "=", "op1", ";", "else", "op1", "=", "op0", ";", "}", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "{", "perm0", "=", "perm0", "&", "1", ";", "perm1", "=", "(", "perm1", "&", "1", ")", "+", "2", ";", "}", "else", "if", "(", "perm0", "&", "2", ")", "{", "if", "(", "perm1", "&", "2", ")", "return", "false", ";", "perm0", "-=", "2", ";", "perm1", "+=", "2", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "}", "else", "if", "(", "(", "perm1", "&", "2", ")", "==", "0", ")", "return", "false", ";", "if", "(", "target", "!=", "NULL", ")", "{", "machine_mode", "vmode", ",", "dmode", ";", "rtvec", "v", ";", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "gcc_assert", "(", "GET_MODE_NUNITS", "(", "vmode", ")", "==", "2", ")", ";", "dmode", "=", "mode_for_vector", "(", "GET_MODE_INNER", "(", "vmode", ")", ",", "4", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "dmode", ",", "op0", ",", "op1", ")", ";", "v", "=", "gen_rtvec", "(", "2", ",", "GEN_INT", "(", "perm0", ")", ",", "GEN_INT", "(", "perm1", ")", ")", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "vmode", ",", "x", ",", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "v", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "Paired", "Single", "or", "VSX", "Permute", "Doubleword", "constant", "permutation", ".", "Return", "true", "if", "we", "match", "an", "efficient", "implementation", "." ]

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

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRBui", ":", "case", "AArch64", "::", "LDRHui", ":", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDR_PXI", ":", "case", "AArch64", "::", "LDR_ZXI", ":", "case", "AArch64", "::", "LDR_ZZXI", ":", "case", "AArch64", "::", "LDR_ZZZXI", ":", "case", "AArch64", "::", "LDR_ZZZZXI", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "AArch64", "AArch64", "AArch64::LDRWui", "AArch64::LDRXui", "AArch64::LDRBui", "AArch64::LDRHui", "AArch64::LDRSui", "AArch64::LDRDui", "AArch64::LDRQui", "AArch64::LDR_PXI", "AArch64::LDR_ZXI", "AArch64::LDR_ZZXI", "AArch64::LDR_ZZZXI", "AArch64::LDR_ZZZZXI", "0", "0", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "Cpu0AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrinterDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "isPseudo", "(", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "&", "*", "I", ",", "TmpInst0", ")", ";", "OutStreamer", "->", "EmitInstruction", "(", "TmpInst0", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "128", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "int", "cr16_interrupt_function_p", "(", "void", ")", "{", "tree", "attributes", ";", "attributes", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "return", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "attributes", ")", "!=", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "current", "function", "being", "compiled", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt", "''", "attribute", "." ]

[ "cr16", "\"interrupt\"" ]

[]

[ "<s>", "bool", "NVPTXTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "!", "AM", ".", "BaseOffs", "&&", "!", "AM", ".", "HasBaseReg", "&&", "!", "AM", ".", "Scale", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "NVPTX", "NVPTX", "0", "1" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIa", ")", "&&", "MIb", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIb", ")", ")", "return", "true", ";", "unsigned", "BasePosA", ",", "OffsetPosA", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIa", ",", "BasePosA", ",", "OffsetPosA", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseA", "=", "MIa", ".", "getOperand", "(", "BasePosA", ")", ";", "Register", "BaseRegA", "=", "BaseA", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubA", "=", "BaseA", ".", "getSubReg", "(", ")", ";", "unsigned", "BasePosB", ",", "OffsetPosB", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIb", ",", "BasePosB", ",", "OffsetPosB", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseB", "=", "MIb", ".", "getOperand", "(", "BasePosB", ")", ";", "Register", "BaseRegB", "=", "BaseB", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubB", "=", "BaseB", ".", "getSubReg", "(", ")", ";", "if", "(", "BaseRegA", "!=", "BaseRegB", "||", "BaseSubA", "!=", "BaseSubB", ")", "return", "false", ";", "unsigned", "SizeA", "=", "getMemAccessSize", "(", "MIa", ")", ";", "unsigned", "SizeB", "=", "getMemAccessSize", "(", "MIb", ")", ";", "const", "MachineOperand", "&", "OffA", "=", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ";", "const", "MachineOperand", "&", "OffB", "=", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ";", "if", "(", "!", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ".", "isImm", "(", ")", "||", "!", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "int", "OffsetA", "=", "isPostIncrement", "(", "MIa", ")", "?", "0", ":", "OffA", ".", "getImm", "(", ")", ";", "int", "OffsetB", "=", "isPostIncrement", "(", "MIb", ")", "?", "0", ":", "OffB", ".", "getImm", "(", ")", ";", "if", "(", "OffsetA", ">", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetA", "-", "(", "int64_t", ")", "OffsetB", ")", ";", "return", "SizeB", "<=", "OffDiff", ";", "}", "if", "(", "OffsetA", "<", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetB", "-", "(", "int64_t", ")", "OffsetA", ")", ";", "return", "SizeA", "<=", "OffDiff", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

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

[]

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

[ "getTOCSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "TOC", "register", "�", "?", "64-bit", "SVR4", "ABI", "only", "." ]

[ "PowerPC" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "static", "size_t", "cygwin_gt_pch_alloc_granularity", "(", "void", ")", "{", "return", "va_granularity", ";", "}", "</s>" ]

[ "Return", "the", "alignment", "required", "for", "allocating", "virtual", "memory", "." ]

[ "i386" ]

[]

[ "<s>", "void", "TGSIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "mf", ",", "MachineBasicBlock", "&", "mbb", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "mbbi", "=", "mbb", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "&", "mfi", "=", "mf", ".", "getFrameInfo", "(", ")", ";", "const", "TGSIInstrInfo", "&", "tii", "=", "*", "static_cast", "<", "const", "TGSIInstrInfo", "*", ">", "(", "mf", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", ";", "int", "frame_sz", "=", "mfi", ".", "getStackSize", "(", ")", ";", "if", "(", "frame_sz", "==", "0", ")", "return", ";", "BuildMI", "(", "mbb", ",", "mbbi", ",", "dl", ",", "tii", ".", "get", "(", "TGSI", "::", "UADDs", ")", ",", "TGSI", "::", "TEMP0x", ")", ".", "addReg", "(", "TGSI", "::", "TEMP0x", ")", ".", "addImm", "(", "-", "frame_sz", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI", "TGSI", "0", "TGSI::UADDs", "TGSI::TEMP0x", "TGSI::TEMP0x" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Module", "&", "M", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "Subtarget", "(", "*", "this", ",", "M", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin_file_start", "(", "void", ")", "{", "static", "const", "struct", "{", "const", "char", "*", "arg", ";", "const", "char", "*", "name", ";", "int", "if_set", ";", "}", "mapping", "[", "]", "=", "{", "{", "\"ppc64\"", ",", "\"ppc64\"", ",", "MASK_64BIT", "}", ",", "{", "\"970\"", ",", "\"ppc970\"", ",", "MASK_PPC_GPOPT", "|", "MASK_MFCRF", "|", "MASK_POWERPC64", "}", ",", "{", "\"power4\"", ",", "\"ppc970\"", ",", "0", "}", ",", "{", "\"G5\"", ",", "\"ppc970\"", ",", "0", "}", ",", "{", "\"7450\"", ",", "\"ppc7450\"", ",", "0", "}", ",", "{", "\"7400\"", ",", "\"ppc7400\"", ",", "MASK_ALTIVEC", "}", ",", "{", "\"G4\"", ",", "\"ppc7400\"", ",", "0", "}", ",", "{", "\"750\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"740\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"G3\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"604e\"", ",", "\"ppc604e\"", ",", "0", "}", ",", "{", "\"604\"", ",", "\"ppc604\"", ",", "0", "}", ",", "{", "\"603e\"", ",", "\"ppc603\"", ",", "0", "}", ",", "{", "\"603\"", ",", "\"ppc603\"", ",", "0", "}", ",", "{", "\"601\"", ",", "\"ppc601\"", ",", "0", "}", ",", "{", "NULL", ",", "\"ppc\"", ",", "0", "}", "}", ";", "const", "char", "*", "cpu_id", "=", "\"\"", ";", "size_t", "i", ";", "rs6000_file_start", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "rs6000_select", ")", ";", "i", "++", ")", "if", "(", "rs6000_select", "[", "i", "]", ".", "set_arch_p", "&&", "rs6000_select", "[", "i", "]", ".", "string", "&&", "rs6000_select", "[", "i", "]", ".", "string", "[", "0", "]", "!=", "'\\0'", ")", "cpu_id", "=", "rs6000_select", "[", "i", "]", ".", "string", ";", "i", "=", "0", ";", "while", "(", "mapping", "[", "i", "]", ".", "arg", "!=", "NULL", "&&", "strcmp", "(", "mapping", "[", "i", "]", ".", "arg", ",", "cpu_id", ")", "!=", "0", "&&", "(", "mapping", "[", "i", "]", ".", "if_set", "&", "target_flags", ")", "==", "0", ")", "i", "++", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machine %s\\n\"", ",", "mapping", "[", "i", "]", ".", "name", ")", ";", "}", "</s>" ]

[ "Output", "a", ".machine", "directive", "for", "the", "Darwin", "assembler", ",", "and", "call", "the", "generic", "start_file", "routine", "." ]

[ "rs6000", "\"ppc64\"", "\"ppc64\"", "\"970\"", "\"ppc970\"", "\"power4\"", "\"ppc970\"", "0", "\"G5\"", "\"ppc970\"", "0", "\"7450\"", "\"ppc7450\"", "0", "\"7400\"", "\"ppc7400\"", "\"G4\"", "\"ppc7400\"", "0", "\"750\"", "\"ppc750\"", "0", "\"740\"", "\"ppc750\"", "0", "\"G3\"", "\"ppc750\"", "0", "\"604e\"", "\"ppc604e\"", "0", "\"604\"", "\"ppc604\"", "0", "\"603e\"", "\"ppc603\"", "0", "\"603\"", "\"ppc603\"", "0", "\"601\"", "\"ppc601\"", "0", "\"ppc\"", "0", "\"\"", "0", "0", "0", "0", "0", "\"\\t.machine %s\\n\"" ]

[]

[ "<s>", "void", "eco32_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "rtx", "operand", "=", "x", ";", "switch", "(", "code", ")", "{", "case", "0", ":", "break", ";", "case", "'H'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "1", "]", ")", ";", "return", ";", "}", "default", ":", "LOSE_AND_RETURN", "(", "\"invalid operand modifier letter\"", ",", "x", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "operand", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "internal_error", "(", "\"internal error: bad register: %d\"", ",", "REGNO", "(", "operand", ")", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "PRINT_OPERAND_ADDRESS", "(", "file", ",", "XEXP", "(", "operand", ",", "0", ")", ")", ";", "return", ";", "default", ":", "if", "(", "CONSTANT_P", "(", "operand", ")", ")", "{", "output_addr_const", "(", "file", ",", "operand", ")", ";", "return", ";", "}", "LOSE_AND_RETURN", "(", "\"unexpected operand\"", ",", "x", ")", ";", "}", "}", "</s>" ]

[ "The", "PRINT_OPERAND", "worker", "." ]

[ "eco32", "0", "\"%s\"", "1", "\"invalid operand modifier letter\"", "\"internal error: bad register: %d\"", "\"%s\"", "0", "\"unexpected operand\"" ]

[]

[ "<s>", "void", "Coloring", "::", "dump", "(", ")", "const", "{", "dbgs", "(", ")", "<<", "\"{ Order: {\"", ";", "for", "(", "Node", "P", ":", "Order", ")", "{", "if", "(", "P", "!=", "Ignore", ")", "dbgs", "(", ")", "<<", "' '", "<<", "P", ";", "else", "dbgs", "(", ")", "<<", "\" -\"", ";", "}", "dbgs", "(", ")", "<<", "\" }\\n\"", ";", "dbgs", "(", ")", "<<", "\" Needed: {\"", ";", "for", "(", "Node", "N", ":", "Needed", ")", "dbgs", "(", ")", "<<", "' '", "<<", "N", ";", "dbgs", "(", ")", "<<", "\" }\\n\"", ";", "dbgs", "(", ")", "<<", "\" Edges: {\\n\"", ";", "for", "(", "auto", "E", ":", "Edges", ")", "{", "dbgs", "(", ")", "<<", "\" \"", "<<", "E", ".", "first", "<<", "\" -> {\"", ";", "for", "(", "auto", "N", ":", "E", ".", "second", ")", "dbgs", "(", ")", "<<", "' '", "<<", "N", ";", "dbgs", "(", ")", "<<", "\" }\\n\"", ";", "}", "dbgs", "(", ")", "<<", "\" }\\n\"", ";", "auto", "ColorKindToName", "=", "[", "]", "(", "ColorKind", "C", ")", "{", "switch", "(", "C", ")", "{", "case", "ColorKind", "::", "None", ":", "return", "\"None\"", ";", "case", "ColorKind", "::", "Red", ":", "return", "\"Red\"", ";", "case", "ColorKind", "::", "Black", ":", "return", "\"Black\"", ";", "}", "llvm_unreachable", "(", "\"all ColorKinds should be handled by the switch above\"", ")", ";", "}", ";", "dbgs", "(", ")", "<<", "\" Colors: {\\n\"", ";", "for", "(", "auto", "C", ":", "Colors", ")", "dbgs", "(", ")", "<<", "\" \"", "<<", "C", ".", "first", "<<", "\" -> \"", "<<", "ColorKindToName", "(", "C", ".", "second", ")", "<<", "\"\\n\"", ";", "dbgs", "(", ")", "<<", "\" }\\n}\\n\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"{ Order: {\"", "\" -\"", "\" }\\n\"", "\" Needed: {\"", "\" }\\n\"", "\" Edges: {\\n\"", "\" \"", "\" -> {\"", "\" }\\n\"", "\" }\\n\"", "\"None\"", "\"Red\"", "\"Black\"", "\"all ColorKinds should be handled by the switch above\"", "\" Colors: {\\n\"", "\" \"", "\" -> \"", "\"\\n\"", "\" }\\n}\\n\"" ]

[]

[ "<s>", "unsigned", "getMachineCSELookAheadLimit", "(", ")", "const", "override", "{", "return", "500", ";", "}", "</s>" ]

[ "Return", "the", "value", "to", "use", "for", "the", "MachineCSE", "'s", "LookAheadLimit", ",", "which", "is", "a", "heuristic", "used", "for", "CSE'ing", "phys", "reg", "defs", "." ]

[ "R600", "500" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "SB", ":", "case", "RISCV", "::", "SH", ":", "case", "RISCV", "::", "SW", ":", "case", "RISCV", "::", "FSH", ":", "case", "RISCV", "::", "FSW", ":", "case", "RISCV", "::", "SD", ":", "case", "RISCV", "::", "FSD", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "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", "." ]

[ "RISCV", "RISCV", "0", "RISCV::SB", "RISCV::SH", "RISCV::SW", "RISCV::FSH", "RISCV::FSW", "RISCV::SD", "RISCV::FSD", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "BitVector", "MSP430RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SR", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CG", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "MSP430", "::", "FPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "FP", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::PCB", "MSP430::SPB", "MSP430::SRB", "MSP430::CGB", "MSP430::PC", "MSP430::SP", "MSP430::SR", "MSP430::CG", "MSP430::FPB", "MSP430::FP" ]

[]

[ "<s>", "static", "bool", "m32c_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "int", "rn", ";", "fprintf", "(", "stderr", ",", "\"can change from %s to %s in %s\\n\"", ",", "mode_name", "[", "from", "]", ",", "mode_name", "[", "to", "]", ",", "class_names", "[", "rclass", "]", ")", ";", "for", "(", "rn", "=", "0", ";", "rn", "<", "FIRST_PSEUDO_REGISTER", ";", "rn", "++", ")", "if", "(", "class_contents", "[", "rclass", "]", "[", "0", "]", "&", "(", "1", "<<", "rn", ")", ")", "if", "(", "!", "m32c_hard_regno_mode_ok", "(", "rn", ",", "to", ")", ")", "return", "false", ";", "if", "(", "to", "==", "QImode", ")", "return", "(", "class_contents", "[", "rclass", "]", "[", "0", "]", "&", "0x1ffa", ")", "==", "0", ";", "if", "(", "class_contents", "[", "rclass", "]", "[", "0", "]", "&", "0x0005", "&&", "GET_MODE_SIZE", "(", "from", ")", ">", "1", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "from", ")", ">", "2", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "TARGET_CAN_CHANGE_MODE_CLASS", ".", "Only", "r0", "and", "r1", "can", "change", "to", "QI", "(", "r0l", ",", "r1l", ")", "because", "the", "chip", "does", "n't", "support", "QI", "ops", "on", "other", "registers", "(", "well", ",", "it", "does", "on", "a0/a1", "but", "if", "we", "let", "gcc", "do", "that", ",", "reload", "suffers", ")", ".", "Otherwise", ",", "we", "allow", "changes", "to", "larger", "modes", "." ]

[ "m32c", "\"can change from %s to %s in %s\\n\"", "0", "0", "1", "0", "0x1ffa", "0", "0", "0x0005", "1", "2" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "G8RC", ":", "GPRC", ";", "unsigned", "Reg", "=", "findScratchRegister", "(", "II", ",", "RS", ",", "RC", ",", "SPAdj", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "Reg", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "Reg", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "false", ",", "true", ",", "true", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "false", ",", "false", ",", "true", ")", ".", "addImm", "(", "PPCRegisterInfo", "::", "getRegisterNumbering", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "false", ",", "false", ",", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "PPC", "0", "PPC::MFCR", "PPC::MFCR", "0", "0", "PPC::CR0", "PPC::RLWINM", "PPC", "4", "0", "31", "PPC::STW", "1" ]

[]

[ "<s>", "static", "void", "mcore_unique_section", "(", "tree", "decl", ",", "int", "reloc", "ATTRIBUTE_UNUSED", ")", "{", "int", "len", ";", "const", "char", "*", "name", ";", "char", "*", "string", ";", "const", "char", "*", "prefix", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "prefix", "=", "\".text$\"", ";", "else", "if", "(", "decl_readonly_section", "(", "decl", ",", "0", ")", ")", "prefix", "=", "\".rdata$\"", ";", "else", "prefix", "=", "\".data$\"", ";", "len", "=", "strlen", "(", "name", ")", "+", "strlen", "(", "prefix", ")", ";", "string", "=", "alloca", "(", "len", "+", "1", ")", ";", "sprintf", "(", "string", ",", "\"%s%s\"", ",", "prefix", ",", "name", ")", ";", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", ",", "string", ")", ";", "}", "</s>" ]

[ "Cover", "function", "for", "UNIQUE_SECTION", "." ]

[ "mcore", "\".text$\"", "0", "\".rdata$\"", "\".data$\"", "1", "\"%s%s\"" ]

[]

[ "<s>", "int", "arc_check_millicode", "(", "rtx", "op", ",", "int", "offset", ",", "int", "load_p", ")", "{", "int", "len", "=", "XVECLEN", "(", "op", ",", "0", ")", "-", "offset", ";", "int", "i", ";", "if", "(", "load_p", "==", "2", ")", "{", "if", "(", "len", "<", "2", "||", "len", ">", "13", ")", "return", "0", ";", "load_p", "=", "1", ";", "}", "else", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "--", "len", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "CLOBBER", "||", "!", "REG_P", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "||", "REGNO", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "!=", "RETURN_ADDR_REGNUM", "||", "len", "<", "3", "||", "len", ">", "13", ")", "return", "0", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<", "len", ";", "i", "++", ")", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", "+", "offset", ")", ";", "rtx", "reg", ",", "mem", ",", "addr", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", ")", "return", "0", ";", "mem", "=", "XEXP", "(", "elt", ",", "load_p", ")", ";", "reg", "=", "XEXP", "(", "elt", ",", "1", "-", "load_p", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "REGNO", "(", "reg", ")", "!=", "13U", "+", "i", "||", "!", "MEM_P", "(", "mem", ")", ")", "return", "0", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", "||", "!", "rtx_equal_p", "(", "stack_pointer_rtx", ",", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "||", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "i", "*", "4", ")", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Check", "if", "OP", "is", "a", "proper", "parallel", "of", "a", "millicode", "call", "pattern", ".", "OFFSET", "indicates", "a", "number", "of", "elements", "to", "ignore", "-", "that", "allows", "to", "have", "a", "sibcall", "pattern", "that", "starts", "with", "(", "return", ")", ".", "LOAD_P", "is", "zero", "for", "store", "multiple", "(", "for", "prologues", ")", ",", "and", "one", "for", "load", "multiples", "(", "for", "epilogues", ")", ",", "and", "two", "for", "load", "multiples", "where", "no", "final", "clobber", "of", "blink", "is", "required", ".", "We", "also", "skip", "the", "first", "load", "/", "store", "element", "since", "this", "is", "supposed", "to", "be", "checked", "in", "the", "instruction", "pattern", "." ]

[ "arc", "0", "2", "2", "13", "0", "1", "0", "0", "0", "3", "13", "0", "1", "0", "0", "1", "13U", "0", "0", "0", "1", "1", "4", "0", "1" ]

[]

[ "<s>", "static", "bool", "arm_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "ARG_REGISTER", "(", "1", ")", "||", "(", "TARGET_32BIT", "&&", "TARGET_AAPCS_BASED", "&&", "TARGET_VFP", "&&", "TARGET_HARD_FLOAT", "&&", "regno", "==", "FIRST_VFP_REGNUM", ")", "||", "(", "TARGET_IWMMXT_ABI", "&&", "regno", "==", "FIRST_IWMMXT_REGNUM", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "arm", "1" ]

[]

[ "<s>", "bool", "X86Subtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "return", "PostRAScheduler", "&&", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "ValueMapping", "*", "AMDGPURegisterBankInfo", "::", "getValueMappingForPtr", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "Register", "PtrReg", ")", "const", "{", "LLT", "PtrTy", "=", "MRI", ".", "getType", "(", "PtrReg", ")", ";", "unsigned", "Size", "=", "PtrTy", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Subtarget", ".", "useFlatForGlobal", "(", ")", "||", "!", "AMDGPU", "::", "isFlatGlobalAddrSpace", "(", "PtrTy", ".", "getAddressSpace", "(", ")", ")", ")", "return", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ";", "const", "RegisterBank", "*", "PtrBank", "=", "getRegBank", "(", "PtrReg", ",", "MRI", ",", "*", "TRI", ")", ";", "return", "AMDGPU", "::", "getValueMapping", "(", "PtrBank", "->", "getID", "(", ")", ",", "Size", ")", ";", "}", "</s>" ]

[ "Return", "the", "mapping", "for", "a", "pointer", "argument", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isFlatGlobalAddrSpace", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "AMDGPU::getValueMapping" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "getMCOpcodeFromPseudo", "(", "Opc", ")", ";", "unsigned", "DescSize", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "isFixedSize", "(", "MI", ")", ")", "return", "DescSize", ";", "if", "(", "isVALU", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src0Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src0Idx", "]", ")", ")", "return", "isVOP3", "(", "MI", ")", "?", "12", ":", "(", "DescSize", "+", "4", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src1Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src1Idx", "]", ")", ")", "return", "isVOP3", "(", "MI", ")", "?", "12", ":", "(", "DescSize", "+", "4", ")", ";", "int", "Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "Src2Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src2Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src2Idx", "]", ")", ")", "return", "isVOP3", "(", "MI", ")", "?", "12", ":", "(", "DescSize", "+", "4", ")", ";", "return", "DescSize", ";", "}", "if", "(", "isMIMG", "(", "MI", ")", ")", "{", "int", "VAddr0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "vaddr0", ")", ";", "if", "(", "VAddr0Idx", "<", "0", ")", "return", "8", ";", "int", "RSrcIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ";", "return", "8", "+", "4", "*", "(", "(", "RSrcIdx", "-", "VAddr0Idx", "+", "2", ")", "/", "4", ")", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "return", "0", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleSize", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ",", "&", "ST", ")", ";", "}", "default", ":", "return", "DescSize", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "12", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "12", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "12", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "8", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "8", "4", "2", "4", "0", "0" ]

[]

[ "<s>", "static", "bool", "cbranch_predicted_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "x", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "0", ")", ";", "if", "(", "x", ")", "{", "return", "profile_probability", "::", "from_reg_br_prob_note", "(", "XINT", "(", "x", ",", "0", ")", ")", ">=", "profile_probability", "::", "even", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "annotated", "with", "a", "REG_BR_PROB", "note", "that", "indicates", "it", "'s", "a", "branch", "that", "'s", "predicted", "taken", "." ]

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

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "M88k" ]

[]

[ "<s>", "static", "bool", "s390_hard_fp_reg_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "(", "REG_P", "(", "x", ")", "&&", "HARD_REGISTER_P", "(", "x", ")", "&&", "REG_ATTRS", "(", "x", ")", ")", ")", "return", "false", ";", "tree", "decl", "=", "REG_EXPR", "(", "x", ")", ";", "if", "(", "!", "(", "HAS_DECL_ASSEMBLER_NAME_P", "(", "decl", ")", "&&", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", ")", ")", "return", "false", ";", "const", "char", "*", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "return", "name", "[", "0", "]", "==", "'*'", "&&", "name", "[", "1", "]", "==", "'f'", ";", "}", "</s>" ]

[ "Return", "TRUE", "iff", "X", "is", "a", "hard", "floating-point", "(", "and", "not", "a", "vector", ")", "register", "." ]

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

[]

[ "<s>", "static", "rtx", "microblaze_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "ret", ";", "int", "regbase", "=", "-", "1", ";", "int", "*", "arg_words", "=", "&", "cum", "->", "arg_words", ";", "cum", "->", "last_arg_fp", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "case", "E_VOIDmode", ":", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "regbase", "=", "GP_ARG_FIRST", ";", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "case", "E_BLKmode", ":", "regbase", "=", "GP_ARG_FIRST", ";", "break", ";", "}", "if", "(", "*", "arg_words", ">=", "MAX_ARGS_IN_REGISTERS", ")", "ret", "=", "0", ";", "else", "{", "gcc_assert", "(", "regbase", "!=", "-", "1", ")", ";", "ret", "=", "gen_rtx_REG", "(", "mode", ",", "regbase", "+", "*", "arg_words", ")", ";", "}", "if", "(", "mode", "==", "VOIDmode", ")", "{", "if", "(", "cum", "->", "num_adjusts", ">", "0", ")", "ret", "=", "gen_rtx_PARALLEL", "(", "(", "machine_mode", ")", "cum", "->", "fp_code", ",", "gen_rtvec_v", "(", "cum", "->", "num_adjusts", ",", "cum", "->", "adjust", ")", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ia64_start_function", "(", "FILE", "*", "file", ",", "const", "char", "*", "fnname", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "vms_start_function", "(", "fnname", ")", ";", "fputs", "(", "\"\\t.proc \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "fnname", ")", ";", "}", "</s>" ]

[ "Output", "the", "textual", "info", "surrounding", "the", "prologue", "." ]

[ "ia64", "\"\\t.proc \"" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AS", "==", "AMDGPUASI", ".", "GLOBAL_ADDRESS", ")", "return", "isLegalGlobalAddressingMode", "(", "AM", ")", ";", "if", "(", "AS", "==", "AMDGPUASI", ".", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "CONSTANT_ADDRESS_32BIT", ")", "{", "if", "(", "AM", ".", "BaseOffs", "%", "4", "!=", "0", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "Ty", "->", "isSized", "(", ")", "&&", "DL", ".", "getTypeStoreSize", "(", "Ty", ")", "<", "4", ")", "return", "isLegalGlobalAddressingMode", "(", "AM", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "32", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "}", "else", "llvm_unreachable", "(", "\"unhandled generation\"", ")", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUASI", ".", "PRIVATE_ADDRESS", ")", "{", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUASI", ".", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "REGION_ADDRESS", ")", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUASI", ".", "FLAT_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "UNKNOWN_ADDRESS_SPACE", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "4", "0", "4", "AMDGPU", "8", "4", "AMDGPU", "32", "4", "AMDGPU", "20", "\"unhandled generation\"", "0", "1", "SI", "SI", "SI", "16", "0", "1", "SI", "SI", "\"unhandled address space\"" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "RegInfo", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "unsigned", "&", "MinCSFrameIndex", ",", "unsigned", "&", "MaxCSFrameIndex", ")", "const", "{", "bool", "NeedsWinCFI", "=", "needsWinCFI", "(", "MF", ")", ";", "if", "(", "NeedsWinCFI", ")", "std", "::", "reverse", "(", "CSI", ".", "begin", "(", ")", ",", "CSI", ".", "end", "(", ")", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "int", "FrameIdx", ";", "unsigned", "Size", "=", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ";", "Align", "Alignment", "(", "RegInfo", "->", "getSpillAlignment", "(", "*", "RC", ")", ")", ";", "FrameIdx", "=", "MFI", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "true", ")", ";", "CS", ".", "setFrameIdx", "(", "FrameIdx", ")", ";", "if", "(", "(", "unsigned", ")", "FrameIdx", "<", "MinCSFrameIndex", ")", "MinCSFrameIndex", "=", "FrameIdx", ";", "if", "(", "(", "unsigned", ")", "FrameIdx", ">", "MaxCSFrameIndex", ")", "MaxCSFrameIndex", "=", "FrameIdx", ";", "if", "(", "hasFP", "(", "MF", ")", "&&", "AFI", "->", "hasSwiftAsyncContext", "(", ")", "&&", "Reg", "==", "AArch64", "::", "FP", ")", "{", "FrameIdx", "=", "MFI", ".", "CreateStackObject", "(", "8", ",", "Alignment", ",", "true", ")", ";", "AFI", "->", "setSwiftAsyncContextFrameIdx", "(", "FrameIdx", ")", ";", "if", "(", "(", "unsigned", ")", "FrameIdx", "<", "MinCSFrameIndex", ")", "MinCSFrameIndex", "=", "FrameIdx", ";", "if", "(", "(", "unsigned", ")", "FrameIdx", ">", "MaxCSFrameIndex", ")", "MaxCSFrameIndex", "=", "FrameIdx", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::FP", "8" ]

[]

[ "<s>", "int", "xstormy16_interrupt_function_p", "(", "void", ")", "{", "tree", "attributes", ";", "if", "(", "!", "cfun", ")", "return", "0", ";", "attributes", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "return", "lookup_attribute", "(", "\"interrupt\"", ",", "attributes", ")", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "function", "is", "an", "interrupt", "function", "." ]

[ "stormy16", "0", "\"interrupt\"" ]

[]

[ "<s>", "static", "void", "sparc_file_end", "(", "void", ")", "{", "if", "(", "got_helper_rtx", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "got_helper_rtx", ",", "0", ")", ";", "const", "char", "*", "reg_name", "=", "reg_names", "[", "GLOBAL_OFFSET_TABLE_REGNUM", "]", ";", "bool", "do_cfi", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "tree", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "DECL_RESULT", "(", "decl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "make_decl_one_only", "(", "decl", ",", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "DECL_VISIBILITY", "(", "decl", ")", "=", "VISIBILITY_HIDDEN", ";", "DECL_VISIBILITY_SPECIFIED", "(", "decl", ")", "=", "1", ";", "resolve_unique_section", "(", "decl", ",", "0", ",", "flag_function_sections", ")", ";", "allocate_struct_function", "(", "decl", ",", "true", ")", ";", "cfun", "->", "is_thunk", "=", "1", ";", "current_function_decl", "=", "decl", ";", "init_varasm_status", "(", ")", ";", "assemble_start_function", "(", "decl", ",", "name", ")", ";", "}", "else", "{", "const", "int", "align", "=", "floor_log2", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "switch_to_section", "(", "text_section", ")", ";", "if", "(", "align", ">", "0", ")", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "align", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "name", ")", ";", "}", "do_cfi", "=", "dwarf2out_do_cfi_asm", "(", ")", ";", "if", "(", "do_cfi", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.cfi_startproc\\n\"", ")", ";", "if", "(", "flag_delayed_branch", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%%o7+8\\n\\t add\\t%%o7, %s, %s\\n\"", ",", "reg_name", ",", "reg_name", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"\\tadd\\t%%o7, %s, %s\\n\\tjmp\\t%%o7+8\\n\\t nop\\n\"", ",", "reg_name", ",", "reg_name", ")", ";", "if", "(", "do_cfi", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.cfi_endproc\\n\"", ")", ";", "}", "if", "(", "NEED_INDICATE_EXEC_STACK", ")", "file_end_indicate_exec_stack", "(", ")", ";", "solaris_file_end", "(", ")", ";", "}", "</s>" ]

[ "Do", "whatever", "processing", "is", "required", "at", "the", "end", "of", "a", "file", "." ]

[ "sparc", "0", "1", "1", "1", "0", "1", "0", "\"\\t.cfi_startproc\\n\"", "\"\\tjmp\\t%%o7+8\\n\\t add\\t%%o7, %s, %s\\n\"", "\"\\tadd\\t%%o7, %s, %s\\n\\tjmp\\t%%o7+8\\n\\t nop\\n\"", "\"\\t.cfi_endproc\\n\"" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "rs6000_maybe_emit_fp_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "compare_rtx", ";", "rtx", "cmove_rtx", ";", "rtx", "clobber_rtx", ";", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "return", "0", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "GE", ":", "case", "GT", ":", "break", ";", "case", "NE", ":", "case", "LT", ":", "case", "LE", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "return", "false", ";", "}", "compare_rtx", "=", "gen_rtx_fmt_ee", "(", "code", ",", "CCFPmode", ",", "op0", ",", "op1", ")", ";", "cmove_rtx", "=", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "compare_rtx", ",", "true_cond", ",", "false_cond", ")", ")", ";", "clobber_rtx", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "V2DImode", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "cmove_rtx", ",", "clobber_rtx", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Possibly", "emit", "a", "floating", "point", "conditional", "move", "by", "generating", "a", "compare", "that", "sets", "a", "mask", "instruction", "and", "a", "XXSEL", "select", "instruction", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "false", "if", "the", "operation", "can", "not", "be", "generated", ",", "and", "true", "if", "we", "could", "generate", "the", "instruction", "." ]

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

[]

[ "<s>", "StringRef", "AArch64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "\"\"", ";", "case", "VK_LO12", ":", "return", "\":lo12:\"", ";", "case", "VK_ABS_G3", ":", "return", "\":abs_g3:\"", ";", "case", "VK_ABS_G2", ":", "return", "\":abs_g2:\"", ";", "case", "VK_ABS_G2_S", ":", "return", "\":abs_g2_s:\"", ";", "case", "VK_ABS_G2_NC", ":", "return", "\":abs_g2_nc:\"", ";", "case", "VK_ABS_G1", ":", "return", "\":abs_g1:\"", ";", "case", "VK_ABS_G1_S", ":", "return", "\":abs_g1_s:\"", ";", "case", "VK_ABS_G1_NC", ":", "return", "\":abs_g1_nc:\"", ";", "case", "VK_ABS_G0", ":", "return", "\":abs_g0:\"", ";", "case", "VK_ABS_G0_S", ":", "return", "\":abs_g0_s:\"", ";", "case", "VK_ABS_G0_NC", ":", "return", "\":abs_g0_nc:\"", ";", "case", "VK_PREL_G3", ":", "return", "\":prel_g3:\"", ";", "case", "VK_PREL_G2", ":", "return", "\":prel_g2:\"", ";", "case", "VK_PREL_G2_NC", ":", "return", "\":prel_g2_nc:\"", ";", "case", "VK_PREL_G1", ":", "return", "\":prel_g1:\"", ";", "case", "VK_PREL_G1_NC", ":", "return", "\":prel_g1_nc:\"", ";", "case", "VK_PREL_G0", ":", "return", "\":prel_g0:\"", ";", "case", "VK_PREL_G0_NC", ":", "return", "\":prel_g0_nc:\"", ";", "case", "VK_DTPREL_G2", ":", "return", "\":dtprel_g2:\"", ";", "case", "VK_DTPREL_G1", ":", "return", "\":dtprel_g1:\"", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "\":dtprel_g1_nc:\"", ";", "case", "VK_DTPREL_G0", ":", "return", "\":dtprel_g0:\"", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "\":dtprel_g0_nc:\"", ";", "case", "VK_DTPREL_HI12", ":", "return", "\":dtprel_hi12:\"", ";", "case", "VK_DTPREL_LO12", ":", "return", "\":dtprel_lo12:\"", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "\":dtprel_lo12_nc:\"", ";", "case", "VK_TPREL_G2", ":", "return", "\":tprel_g2:\"", ";", "case", "VK_TPREL_G1", ":", "return", "\":tprel_g1:\"", ";", "case", "VK_TPREL_G1_NC", ":", "return", "\":tprel_g1_nc:\"", ";", "case", "VK_TPREL_G0", ":", "return", "\":tprel_g0:\"", ";", "case", "VK_TPREL_G0_NC", ":", "return", "\":tprel_g0_nc:\"", ";", "case", "VK_TPREL_HI12", ":", "return", "\":tprel_hi12:\"", ";", "case", "VK_TPREL_LO12", ":", "return", "\":tprel_lo12:\"", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "\":tprel_lo12_nc:\"", ";", "case", "VK_TLSDESC_LO12", ":", "return", "\":tlsdesc_lo12:\"", ";", "case", "VK_ABS_PAGE", ":", "return", "\"\"", ";", "case", "VK_ABS_PAGE_NC", ":", "return", "\":pg_hi21_nc:\"", ";", "case", "VK_GOT", ":", "return", "\":got:\"", ";", "case", "VK_GOT_PAGE", ":", "return", "\":got:\"", ";", "case", "VK_GOT_LO12", ":", "return", "\":got_lo12:\"", ";", "case", "VK_GOTTPREL", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "\":gottprel_lo12:\"", ";", "case", "VK_GOTTPREL_G1", ":", "return", "\":gottprel_g1:\"", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "\":gottprel_g0_nc:\"", ";", "case", "VK_TLSDESC", ":", "return", "\"\"", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "\":tlsdesc:\"", ";", "case", "VK_SECREL_LO12", ":", "return", "\":secrel_lo12:\"", ";", "case", "VK_SECREL_HI12", ":", "return", "\":secrel_hi12:\"", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "AArch64", "AArch64", "\"\"", "\":lo12:\"", "\":abs_g3:\"", "\":abs_g2:\"", "\":abs_g2_s:\"", "\":abs_g2_nc:\"", "\":abs_g1:\"", "\":abs_g1_s:\"", "\":abs_g1_nc:\"", "\":abs_g0:\"", "\":abs_g0_s:\"", "\":abs_g0_nc:\"", "\":prel_g3:\"", "\":prel_g2:\"", "\":prel_g2_nc:\"", "\":prel_g1:\"", "\":prel_g1_nc:\"", "\":prel_g0:\"", "\":prel_g0_nc:\"", "\":dtprel_g2:\"", "\":dtprel_g1:\"", "\":dtprel_g1_nc:\"", "\":dtprel_g0:\"", "\":dtprel_g0_nc:\"", "\":dtprel_hi12:\"", "\":dtprel_lo12:\"", "\":dtprel_lo12_nc:\"", "\":tprel_g2:\"", "\":tprel_g1:\"", "\":tprel_g1_nc:\"", "\":tprel_g0:\"", "\":tprel_g0_nc:\"", "\":tprel_hi12:\"", "\":tprel_lo12:\"", "\":tprel_lo12_nc:\"", "\":tlsdesc_lo12:\"", "\"\"", "\":pg_hi21_nc:\"", "\":got:\"", "\":got:\"", "\":got_lo12:\"", "\":gottprel:\"", "\":gottprel:\"", "\":gottprel_lo12:\"", "\":gottprel_g1:\"", "\":gottprel_g0_nc:\"", "\"\"", "\":tlsdesc:\"", "\":secrel_lo12:\"", "\":secrel_hi12:\"", "\"Invalid ELF symbol kind\"" ]

[]

[ "<s>", "unsigned", "stackAlignment", "(", ")", "const", "{", "return", "hasMips64", "(", ")", "?", "16", ":", "8", ";", "}", "</s>" ]

[ "The", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "." ]

[ "Mips", "Mips", "16", "8" ]

[]

[ "<s>", "void", "i386_pe_record_exported_symbol", "(", "const", "char", "*", "name", ",", "int", "is_data", ")", "{", "struct", "export_list", "*", "p", ";", "p", "=", "(", "struct", "export_list", "*", ")", "ggc_alloc", "(", "sizeof", "*", "p", ")", ";", "p", "->", "next", "=", "export_head", ";", "p", "->", "name", "=", "name", ";", "p", "->", "is_data", "=", "is_data", ";", "export_head", "=", "p", ";", "}", "</s>" ]

[ "Assemble", "an", "export", "symbol", "entry", ".", "We", "need", "to", "keep", "a", "list", "of", "these", ",", "so", "that", "we", "can", "output", "the", "export", "list", "at", "the", "end", "of", "the", "assembly", ".", "We", "used", "to", "output", "these", "export", "symbols", "in", "each", "function", ",", "but", "that", "causes", "problems", "with", "GNU", "ld", "when", "the", "sections", "are", "linkonce", "." ]

[ "i386" ]

[]

[ "<s>", "void", "riscv_expand_float_scc", "(", "rtx", "target", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "riscv_emit_float_compare", "(", "&", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "rtx", "cmp", "=", "riscv_force_binary", "(", "word_mode", ",", "code", ",", "op0", ",", "op1", ")", ";", "riscv_emit_set", "(", "target", ",", "lowpart_subreg", "(", "SImode", ",", "cmp", ",", "word_mode", ")", ")", ";", "}", "</s>" ]

[ "Like", "riscv_expand_int_scc", ",", "but", "for", "floating-point", "comparisons", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "aarch64_mask_and_shift_for_ubfiz_p", "(", "scalar_int_mode", "mode", ",", "rtx", "mask", ",", "rtx", "shft_amnt", ")", "{", "return", "CONST_INT_P", "(", "mask", ")", "&&", "CONST_INT_P", "(", "shft_amnt", ")", "&&", "INTVAL", "(", "mask", ")", ">", "0", "&&", "UINTVAL", "(", "shft_amnt", ")", "<", "GET_MODE_BITSIZE", "(", "mode", ")", "&&", "exact_log2", "(", "(", "UINTVAL", "(", "mask", ")", ">>", "UINTVAL", "(", "shft_amnt", ")", ")", "+", "1", ")", ">=", "0", "&&", "(", "UINTVAL", "(", "mask", ")", "&", "(", "(", "HOST_WIDE_INT_1U", "<<", "UINTVAL", "(", "shft_amnt", ")", ")", "-", "1", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "mask", "and", "a", "shift", "amount", "from", "an", "RTX", "of", "the", "form", "(", "x", "<", "<", "SHFT_AMNT", ")", "&", "MASK", "are", "valid", "to", "combine", "into", "a", "UBFIZ", "instruction", "of", "mode", "MODE", ".", "See", "the", "*", "andim_ashift", "<", "mode", ">", "_bfiz", "pattern", "." ]

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

[]

[ "<s>", "bool", "aarch64_stepped_int_parallel_p", "(", "rtx", "op", ",", "int", "step", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PARALLEL", "||", "!", "CONST_INT_P", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "base", "=", "UINTVAL", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "XVECLEN", "(", "op", ",", "0", ")", ";", "++", "i", ")", "if", "(", "!", "CONST_INT_P", "(", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ")", "||", "UINTVAL", "(", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ")", "!=", "base", "+", "i", "*", "step", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "PARALLEL", "of", "CONST_INTs", "that", "form", "a", "linear", "series", "with", "step", "STEP", "." ]

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

[]

[ "<s>", "void", "HexagonAsmInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "RawPrinter", "->", "printRegName", "(", "O", ",", "RegNo", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "rtx", "promote_duplicated_reg", "(", "machine_mode", "mode", ",", "rtx", "val", ")", "{", "machine_mode", "valmode", "=", "GET_MODE", "(", "val", ")", ";", "rtx", "tmp", ";", "int", "nops", "=", "mode", "==", "DImode", "?", "3", ":", "2", ";", "gcc_assert", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "val", "==", "const0_rtx", ")", ";", "if", "(", "val", "==", "const0_rtx", ")", "return", "copy_to_mode_reg", "(", "mode", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "val", ")", ")", "{", "HOST_WIDE_INT", "v", "=", "INTVAL", "(", "val", ")", "&", "255", ";", "v", "|=", "v", "<<", "8", ";", "v", "|=", "v", "<<", "16", ";", "if", "(", "mode", "==", "DImode", ")", "v", "|=", "(", "v", "<<", "16", ")", "<<", "16", ";", "return", "copy_to_mode_reg", "(", "mode", ",", "gen_int_mode", "(", "v", ",", "mode", ")", ")", ";", "}", "if", "(", "valmode", "==", "VOIDmode", ")", "valmode", "=", "QImode", ";", "if", "(", "valmode", "!=", "QImode", ")", "val", "=", "gen_lowpart", "(", "QImode", ",", "val", ")", ";", "if", "(", "mode", "==", "QImode", ")", "return", "val", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "nops", "--", ";", "if", "(", "ix86_cost", "->", "mult_init", "[", "mode", "==", "DImode", "?", "3", ":", "2", "]", "+", "ix86_cost", "->", "mult_bit", "*", "(", "mode", "==", "DImode", "?", "8", ":", "4", ")", "<=", "(", "ix86_cost", "->", "shift_const", "+", "ix86_cost", "->", "add", ")", "*", "nops", "+", "(", "COSTS_N_INSNS", "(", "TARGET_PARTIAL_REG_STALL", "==", "0", ")", ")", ")", "{", "rtx", "reg", "=", "convert_modes", "(", "mode", ",", "QImode", ",", "val", ",", "true", ")", ";", "tmp", "=", "promote_duplicated_reg", "(", "mode", ",", "const1_rtx", ")", ";", "return", "expand_simple_binop", "(", "mode", ",", "MULT", ",", "reg", ",", "tmp", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "else", "{", "rtx", "reg", "=", "convert_modes", "(", "mode", ",", "QImode", ",", "val", ",", "true", ")", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "emit_insn", "(", "gen_insv_1", "(", "mode", ",", "reg", ",", "reg", ")", ")", ";", "else", "{", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFT", ",", "reg", ",", "GEN_INT", "(", "8", ")", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "reg", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "reg", ",", "tmp", ",", "reg", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFT", ",", "reg", ",", "GEN_INT", "(", "16", ")", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "reg", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "reg", ",", "tmp", ",", "reg", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "reg", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFT", ",", "reg", ",", "GEN_INT", "(", "32", ")", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "reg", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "reg", ",", "tmp", ",", "reg", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "return", "reg", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "memcpy", ".", "For", "QImode", "value", "0xXY", "produce", "0xXYXYXYXY", "of", "wide", "specified", "by", "MODE", ".", "This", "is", "essentially", "a", "*", "0x10101010", ",", "but", "we", "can", "do", "slightly", "better", "than", "synth_mult", "by", "unwinding", "the", "sequence", "by", "hand", "on", "CPUs", "with", "slow", "multiply", "." ]

[ "i386", "3", "2", "255", "8", "16", "16", "16", "3", "2", "8", "4", "0", "1", "8", "1", "1", "16", "1", "1", "32", "1", "1" ]

[]

[ "<s>", "Register", "MINA32RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MINA32", "::", "R11", ":", "MINA32", "::", "SP", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "MINA32::R11", "MINA32::SP" ]

[]

[ "<s>", "void", "m32c_output_reg_push", "(", "FILE", "*", "s", ",", "int", "regno", ")", "{", "if", "(", "regno", "==", "FLG_REGNO", ")", "fprintf", "(", "s", ",", "\"\\tpushc\\tflg\\n\"", ")", ";", "else", "fprintf", "(", "s", ",", "\"\\tpush.%c\\t%s\\n\"", ",", "\" bwll\"", "[", "reg_push_size", "(", "regno", ")", "]", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "</s>" ]

[ "Implements", "ASM_OUTPUT_REG_PUSH", ".", "Control", "registers", "are", "pushed", "differently", "than", "general", "registers", "." ]

[ "m32c", "\"\\tpushc\\tflg\\n\"", "\"\\tpush.%c\\t%s\\n\"", "\" bwll\"" ]

[]