Datasets:

---

docz1105

/

ComBack

like 9

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

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

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

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_i32", ":", "case", "WebAssembly", "::", "ARGUMENT_i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_i64", ":", "case", "WebAssembly", "::", "ARGUMENT_i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f32", ":", "case", "WebAssembly", "::", "ARGUMENT_f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f64", ":", "case", "WebAssembly", "::", "ARGUMENT_f64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64_S", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN", ":", "{", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "COMPILER_FENCE", ":", "break", ";", "case", "WebAssembly", "::", "EXTRACT_EXCEPTION_I32", ":", "case", "WebAssembly", "::", "EXTRACT_EXCEPTION_I32_S", ":", "if", "(", "!", "WasmKeepRegisters", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_i32", "WebAssembly::ARGUMENT_i32_S", "WebAssembly::ARGUMENT_i64", "WebAssembly::ARGUMENT_i64_S", "WebAssembly::ARGUMENT_f32", "WebAssembly::ARGUMENT_f32_S", "WebAssembly::ARGUMENT_f64", "WebAssembly::ARGUMENT_f64_S", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::ARGUMENT_v16i8_S", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::ARGUMENT_v8i16_S", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::ARGUMENT_v4i32_S", "WebAssembly::ARGUMENT_v2i64", "WebAssembly::ARGUMENT_v2i64_S", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::ARGUMENT_v4f32_S", "WebAssembly::ARGUMENT_v2f64", "WebAssembly::ARGUMENT_v2f64_S", "WebAssembly::FALLTHROUGH_RETURN", "\"fallthrough-return\"", "WebAssembly::COMPILER_FENCE", "WebAssembly::EXTRACT_EXCEPTION_I32", "WebAssembly::EXTRACT_EXCEPTION_I32_S", "WebAssembly" ]

[]

[ "<s>", "static", "bool", "sparc_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "aligned_p", "&&", "size", "==", "8", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "if", "(", "TARGET_V9", ")", "{", "assemble_integer_with_op", "(", "\"\\t.xword\\t\"", ",", "x", ")", ";", "return", "true", ";", "}", "else", "{", "assemble_aligned_integer", "(", "4", ",", "const0_rtx", ")", ";", "assemble_aligned_integer", "(", "4", ",", "x", ")", ";", "return", "true", ";", "}", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "sparc", "version", "has", "special", "handling", "for", "aligned", "DI-mode", "objects", "." ]

[ "sparc", "8", "\"\\t.xword\\t\"", "4", "4" ]

[]

[ "<s>", "SDNode", "*", "Z80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Z80", "Z80", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "\"\\n\"" ]

[]

[ "<s>", "const", "Thumb1RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "Register", "X86FrameLowering", "::", "getInitialCFARegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "TRI", "->", "getDwarfRegNum", "(", "StackPtr", ",", "true", ")", ";", "}", "</s>" ]

[ "Return", "initial", "CFA", "register", "value", "i.e", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "mayAlias", "(", "MachineInstr", "&", "MIa", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "MemInsns", ",", "AliasAnalysis", "*", "AA", ")", "{", "for", "(", "MachineInstr", "*", "MIb", ":", "MemInsns", ")", "if", "(", "MIa", ".", "mayAlias", "(", "AA", ",", "*", "MIb", ",", "false", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "instruction", "'s", "memory", "access", "aliases", "the", "memory", "access", "of", "Other", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "if", "(", "(", "Count", "%", "2", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "OW", "->", "write16", "(", "0x9", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "J2", "2", "0", "0", "2", "0x9" ]

[]

[ "<s>", "rtx", "extract_nth_access_rtx", "(", "rtx_insn", "*", "insn", ",", "int", "n", ")", "{", "int", "n_elems", "=", "parallel_elements", "(", "insn", ")", ";", "int", "post_update_rtx_index", "=", "find_post_update_rtx", "(", "insn", ")", ";", "memory_access_direction", "direction", "=", "determine_access_direction", "(", "insn", ")", ";", "gcc_assert", "(", "direction", "!=", "MEM_ACCESS_DIR_UNKNOWN", ")", ";", "if", "(", "direction", "==", "MEM_ACCESS_DIR_NEG", ")", "n", "=", "-", "1", "*", "n", "-", "1", ";", "if", "(", "post_update_rtx_index", "!=", "-", "1", ")", "{", "if", "(", "n", ">=", "0", "&&", "post_update_rtx_index", "<=", "n", ")", "++", "n", ";", "else", "if", "(", "n", "<", "0", "&&", "post_update_rtx_index", ">=", "n", "+", "n_elems", ")", "--", "n", ";", "}", "return", "parallel_element", "(", "insn", ",", "n", ")", ";", "}", "</s>" ]

[ "Return", "the", "nth", "load/store", "operation", "in", "the", "real", "micro-operation", "accessing", "order", "." ]

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVUPSrm_Int", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "isInvariantLoad", "(", "AA", ")", ")", "{", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", "||", "BaseReg", "==", "X86", "::", "RIP", ")", "return", "true", ";", "if", "(", "!", "ReMatPICStubLoad", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", ")", "return", "false", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isPICBase", "=", "false", ";", "for", "(", "MachineRegisterInfo", "::", "def_iterator", "I", "=", "MRI", ".", "def_begin", "(", "BaseReg", ")", ",", "E", "=", "MRI", ".", "def_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "DefMI", "=", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", ";", "if", "(", "DefMI", "->", "getOpcode", "(", ")", "!=", "X86", "::", "MOVPC32r", ")", "return", "false", ";", "assert", "(", "!", "isPICBase", "&&", "\"More than one PIC base?\"", ")", ";", "isPICBase", "=", "true", ";", "}", "return", "isPICBase", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "LEA32r", ":", "case", "X86", "::", "LEA64r", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "!", "MI", "->", "getOperand", "(", "4", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp64m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVUPSrm_Int", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "1", "2", "3", "3", "0", "1", "0", "X86::RIP", "4", "X86::MOVPC32r", "\"More than one PIC base?\"", "X86::LEA32r", "X86::LEA64r", "2", "3", "3", "0", "4", "1", "1", "0" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "shouldForceImediateOperand", "(", "Name", ",", "0", ")", ")", ")", "return", "true", ";", "unsigned", "OperandIdx", "=", "1", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "shouldForceImediateOperand", "(", "Name", ",", "OperandIdx", ")", ")", ")", "return", "true", ";", "++", "OperandIdx", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "RISCV", "RISCV", "RISCV", "0", "1", "\"unexpected token\"" ]

[]

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

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

[ "VE", "VE" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "padShortFunctions", "(", ")", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "LEAusesAG", "(", ")", ")", "{", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_file_end", "(", "void", ")", "{", "switch_to_section", "(", "text_section", ")", ";", "fputs", "(", "\"_section_.text:\\n\"", ",", "asm_out_file", ")", ";", "switch_to_section", "(", "data_section", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long _section_.text\\n\"", ":", "\"\\t.llong _section_.text\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "at", "end", "of", "assembler", "file", ".", "On", "the", "RS/6000", ",", "referencing", "data", "should", "automatically", "pull", "in", "text", "." ]

[ "powerpcspe", "\"_section_.text:\\n\"", "\"\\t.long _section_.text\\n\"", "\"\\t.llong _section_.text\\n\"" ]

[]

[ "<s>", "void", "buildLoad", "(", "unsigned", "Val", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "unsigned", "Alignment", ",", "MachinePointerInfo", "&", "MPO", ")", "{", "MachineMemOperand", "*", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Alignment", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "Val", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "void", "tilegx_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "POST_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", ")", "{", "int", "offset", "=", "GET_MODE_SIZE", "(", "output_memory_reference_mode", ")", ";", "gcc_assert", "(", "output_memory_reference_mode", "!=", "VOIDmode", ")", ";", "if", "(", "output_memory_autoinc_first", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%d\"", ",", "GET_CODE", "(", "addr", ")", "==", "POST_DEC", "?", "-", "offset", ":", "offset", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "POST_MODIFY", ")", "{", "gcc_assert", "(", "output_memory_reference_mode", "!=", "VOIDmode", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "PLUS", ")", ";", "if", "(", "output_memory_autoinc_first", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "1", ")", ")", ")", ";", "}", "else", "tilegx_print_operand", "(", "file", ",", "addr", ",", "'r'", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "tilegx", "\"%s\"", "0", "\"%d\"", "1", "\"%s\"", "0", "1", "1" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_2vperm2f128_vshuf", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "struct", "expand_vec_perm_d", "dfirst", ",", "dsecond", ",", "dthird", ";", "bool", "ok", ";", "if", "(", "!", "TARGET_AVX", "||", "(", "d", "->", "vmode", "!=", "V4DFmode", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "dfirst", "=", "*", "d", ";", "dsecond", "=", "*", "d", ";", "dthird", "=", "*", "d", ";", "dfirst", ".", "perm", "[", "0", "]", "=", "(", "d", "->", "perm", "[", "0", "]", "&", "~", "1", ")", ";", "dfirst", ".", "perm", "[", "1", "]", "=", "(", "d", "->", "perm", "[", "0", "]", "&", "~", "1", ")", "+", "1", ";", "dfirst", ".", "perm", "[", "2", "]", "=", "(", "d", "->", "perm", "[", "2", "]", "&", "~", "1", ")", ";", "dfirst", ".", "perm", "[", "3", "]", "=", "(", "d", "->", "perm", "[", "2", "]", "&", "~", "1", ")", "+", "1", ";", "dsecond", ".", "perm", "[", "0", "]", "=", "(", "d", "->", "perm", "[", "1", "]", "&", "~", "1", ")", ";", "dsecond", ".", "perm", "[", "1", "]", "=", "(", "d", "->", "perm", "[", "1", "]", "&", "~", "1", ")", "+", "1", ";", "dsecond", ".", "perm", "[", "2", "]", "=", "(", "d", "->", "perm", "[", "3", "]", "&", "~", "1", ")", ";", "dsecond", ".", "perm", "[", "3", "]", "=", "(", "d", "->", "perm", "[", "3", "]", "&", "~", "1", ")", "+", "1", ";", "dthird", ".", "perm", "[", "0", "]", "=", "(", "d", "->", "perm", "[", "0", "]", "%", "2", ")", ";", "dthird", ".", "perm", "[", "1", "]", "=", "(", "d", "->", "perm", "[", "1", "]", "%", "2", ")", "+", "4", ";", "dthird", ".", "perm", "[", "2", "]", "=", "(", "d", "->", "perm", "[", "2", "]", "%", "2", ")", "+", "2", ";", "dthird", ".", "perm", "[", "3", "]", "=", "(", "d", "->", "perm", "[", "3", "]", "%", "2", ")", "+", "6", ";", "dfirst", ".", "target", "=", "gen_reg_rtx", "(", "dfirst", ".", "vmode", ")", ";", "dsecond", ".", "target", "=", "gen_reg_rtx", "(", "dsecond", ".", "vmode", ")", ";", "dthird", ".", "op0", "=", "dfirst", ".", "target", ";", "dthird", ".", "op1", "=", "dsecond", ".", "target", ";", "dthird", ".", "one_operand_p", "=", "false", ";", "canonicalize_perm", "(", "&", "dfirst", ")", ";", "canonicalize_perm", "(", "&", "dsecond", ")", ";", "ok", "=", "expand_vec_perm_1", "(", "&", "dfirst", ")", "&&", "expand_vec_perm_1", "(", "&", "dsecond", ")", "&&", "expand_vec_perm_1", "(", "&", "dthird", ")", ";", "gcc_assert", "(", "ok", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_builtin_1", ".", "Implement", "a", "V4DF", "permutation", "using", "two", "vperm2f128", ",", "followed", "by", "a", "vshufpd", "insn", "blending", "the", "two", "vectors", "together", "." ]

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

[]

[ "<s>", "void", "TOYRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "llvm_unreachable", "(", "\"eliminateCallFramePseudoInstr not implemented yet\"", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"eliminateCallFramePseudoInstr not implemented yet\"" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "RISCV", "::", "LD", ":", "RISCV", "::", "LW", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLD", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::LD", "RISCV::LW", "RISCV::FPR32RegClass", "RISCV::FLW", "RISCV::FPR64RegClass", "RISCV::FLD", "\"Can't load this register from stack slot\"", "0" ]

[]

[ "<s>", "void", "MandarinInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "if", "(", "RC", "==", "&", "MD", "::", "GenericRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MD", "::", "LOADrr", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "}", "</s>" ]

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

[ "Mandarin", "MD::GenericRegsRegClass", "MD::LOADrr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "bool", "GBZ80MCExpr", "::", "evaluateAsConstant", "(", "int64_t", "&", "Result", ")", "const", "{", "MCValue", "Value", ";", "bool", "isRelocatable", "=", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "Value", ",", "nullptr", ",", "nullptr", ")", ";", "if", "(", "!", "isRelocatable", ")", "return", "false", ";", "if", "(", "Value", ".", "isAbsolute", "(", ")", ")", "{", "Result", "=", "evaluateAsInt64", "(", "Value", ".", "getConstant", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Evaluates", "the", "fixup", "as", "a", "constant", "value", "." ]

[ "GBZ80", "GB" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "addPass", "(", "createX86DomainReassignmentPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldFoldConstantShiftPairToMask", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "assert", "(", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "&&", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", ")", "&&", "\"Expected shift-shift mask\"", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "Subtarget", ".", "hasFastVectorShiftMasks", "(", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "||", "(", "Subtarget", ".", "hasFastScalarShiftMasks", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", ")", ")", "{", "return", "N", "->", "getOperand", "(", "1", ")", "==", "N", "->", "getOperand", "(", "0", ")", ".", "getOperand", "(", "1", ")", ";", "}", "return", "TargetLoweringBase", "::", "shouldFoldConstantShiftPairToMask", "(", "N", ",", "Level", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "fold", "a", "pair", "of", "shifts", "into", "a", "mask", "." ]

[ "X86", "X86", "ISD::SHL", "0", "ISD::SRL", "ISD::SRL", "0", "ISD::SHL", "\"Expected shift-shift mask\"", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "fr30_must_pass_in_stack", "(", "const", "function_arg_info", "&", "arg", ")", "{", "return", "arg", ".", "mode", "==", "BLKmode", "||", "arg", ".", "aggregate_type_p", "(", ")", ";", "}", "</s>" ]

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

[ "fr30" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "0x60000000", ",", "Endian", ")", ";", "OS", ".", "write_zeros", "(", "Count", "%", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "4", "0", "support::endian", "0x60000000", "4" ]

[]

[ "<s>", "static", "void", "rs6000_function_specific_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "rs6000_print_isa_options", "(", "file", ",", "indent", ",", "\"Isa options set\"", ",", "ptr", "->", "x_rs6000_isa_flags", ")", ";", "rs6000_print_isa_options", "(", "file", ",", "indent", ",", "\"Isa options explicit\"", ",", "ptr", "->", "x_rs6000_isa_flags_explicit", ")", ";", "}", "</s>" ]

[ "Print", "the", "current", "options" ]

[ "powerpcspe", "\"Isa options set\"", "\"Isa options explicit\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "alpha_extract_integer", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "x", "=", "simplify_subreg", "(", "DImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "0", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "x", ")", ")", ";", "return", "INTVAL", "(", "x", ")", ";", "}", "</s>" ]

[ "Given", "an", "integral", "CONST_INT", ",", "CONST_DOUBLE", ",", "or", "CONST_VECTOR", ",", "return", "the", "low", "64", "bits", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "MBlaze" ]

[]

[ "<s>", "bool", "Dcpu16PassConfig", "::", "addInstSelector", "(", ")", "{", "PM", ".", "add", "(", "createDcpu16ISelDag", "(", "getDcpu16TargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Dcpu16" ]

[]

[ "<s>", "static", "scalar_int_mode", "avr_addr_space_pointer_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addr_space_address_mode", "(", "as", ")", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_POINTER_MODE", "'", "." ]

[ "avr" ]

[]

[ "<s>", "AMDGPUSubtarget", "&", "AMDGPUSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+fp64-denormals,+load-store-opt,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-buffer-access,\"", ";", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", ")", "{", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "FP16Denormals", "=", "false", ";", "FP32Denormals", "=", "false", ";", "FP64Denormals", "=", "false", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "256", "\"+promote-alloca,+fp64-denormals,+load-store-opt,\"", "\"+flat-for-global,+unaligned-buffer-access,\"", "\"flat-for-global\"", "AMDGPU", "0", "4" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "Count", "=", "CSI", ".", "size", "(", ")", ";", "DebugLoc", "DL", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "{", "unsigned", "idx", "=", "Count", "-", "i", "-", "2", ";", "unsigned", "Reg1", "=", "CSI", "[", "idx", "]", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "CSI", "[", "idx", "+", "1", "]", ".", "getReg", "(", ")", ";", "assert", "(", "CSI", "[", "idx", "]", ".", "getFrameIdx", "(", ")", "+", "1", "==", "CSI", "[", "idx", "+", "1", "]", ".", "getFrameIdx", "(", ")", "&&", "\"Out of order callee saved regs!\"", ")", ";", "unsigned", "StrOpc", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "assert", "(", "(", "i", "&", "1", ")", "==", "0", "&&", "\"Odd index for callee-saved reg spill!\"", ")", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected GPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "0", ")", "StrOpc", "=", "AArch64", "::", "STPXpre", ";", "else", "StrOpc", "=", "AArch64", "::", "STPXi", ";", "}", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected FPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "0", ")", "StrOpc", "=", "AArch64", "::", "STPDpre", ";", "else", "StrOpc", "=", "AArch64", "::", "STPDi", ";", "}", "else", "llvm_unreachable", "(", "\"Unexpected callee saved register!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", "<<", "\") -> fi#(\"", "<<", "CSI", "[", "idx", "]", ".", "getFrameIdx", "(", ")", "<<", "\", \"", "<<", "CSI", "[", "idx", "+", "1", "]", ".", "getFrameIdx", "(", ")", "<<", "\")\\n\"", ")", ";", "const", "int", "Offset", "=", "(", "i", "==", "0", ")", "?", "-", "Count", ":", "i", ";", "assert", "(", "(", "Offset", ">=", "-", "64", "&&", "Offset", "<=", "63", ")", "&&", "\"Offset out of bounds for STP immediate\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "StrOpc", "==", "AArch64", "::", "STPDpre", "||", "StrOpc", "==", "AArch64", "::", "STPXpre", ")", "MIB", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "0", "2", "2", "1", "1", "1", "\"Out of order callee saved regs!\"", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "1", "0", "\"Odd index for callee-saved reg spill!\"", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "\"Expected GPR64 callee-saved register pair!\"", "0", "AArch64::STPXpre", "AArch64::STPXi", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Expected FPR64 callee-saved register pair!\"", "0", "AArch64::STPDpre", "AArch64::STPDi", "\"Unexpected callee saved register!\"", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "0", "64", "63", "\"Offset out of bounds for STP immediate\"", "AArch64::STPDpre", "AArch64::STPXpre", "AArch64::SP", "AArch64::SP" ]

[]

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

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

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

[]

[ "<s>", "void", "GBZ80PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createGBZ80PreEmitPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB" ]

[]

[ "<s>", "static", "machine_mode", "riscv_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", "ATTRIBUTE_UNUSED", ")", "{", "int", "unsignedp", ";", "if", "(", "type", "!=", "NULL_TREE", ")", "return", "promote_mode", "(", "type", ",", "mode", ",", "punsignedp", ")", ";", "unsignedp", "=", "*", "punsignedp", ";", "PROMOTE_MODE", "(", "as_a", "<", "scalar_mode", ">", "(", "mode", ")", ",", "unsignedp", ",", "type", ")", ";", "*", "punsignedp", "=", "unsignedp", ";", "return", "mode", ";", "}", "</s>" ]

[ "This", "function", "is", "equivalent", "to", "default_promote_function_mode_always_promote", "except", "that", "it", "returns", "a", "promoted", "mode", "even", "if", "type", "is", "NULL_TREE", ".", "This", "is", "needed", "by", "libcalls", "which", "have", "no", "type", "(", "only", "a", "mode", ")", "such", "as", "fixed", "conversion", "routines", "that", "take", "a", "signed", "or", "unsigned", "char/short/int", "argument", "and", "convert", "it", "to", "a", "fixed", "type", "." ]

[ "riscv" ]

[]

[ "<s>", "TargetPassConfig", "*", "SparcTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "SparcPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

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

[]

[ "<s>", "const", "char", "*", "Z80TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Z80ISD", "::", "CALL", ":", "return", "\"Z80ISD::CALL\"", ";", "case", "Z80ISD", "::", "RET", ":", "return", "\"Z80ISD::RET\"", ";", "case", "Z80ISD", "::", "SEXTLOAD_I8", ":", "return", "\"Z80ISD::SEXTLOAD_i8\"", ";", "case", "Z80ISD", "::", "ZEXTLOAD_I8", ":", "return", "\"Z80ISD::ZEXTLOAD_i8\"", ";", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80ISD::CALL", "\"Z80ISD::CALL\"", "Z80ISD::RET", "\"Z80ISD::RET\"", "Z80ISD::SEXTLOAD_I8", "\"Z80ISD::SEXTLOAD_i8\"", "Z80ISD::ZEXTLOAD_I8", "\"Z80ISD::ZEXTLOAD_i8\"" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "Scale", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", "&&", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "AM", ".", "BaseOffs", "==", "0", ";", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "isInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "0", "8" ]

[]

[ "<s>", "bool", "mcore_r15_operand_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "return", "mcore_const_ok_for_inline", "(", "INTVAL", "(", "x", ")", ")", ";", "case", "REG", ":", "case", "SUBREG", ":", "case", "MEM", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "something", "that", "can", "be", "moved", "directly", "into", "r15", "." ]

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

[]

[ "<s>", "bool", "SNITCHFrepLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"------------ Snitch Frep Loops ------------\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "RISCVSubtarget", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "TII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "L", ":", "*", "MLI", ")", "if", "(", "L", "->", "isOutermost", "(", ")", ")", "{", "FL", "=", "new", "FrepLoop", "(", "L", ")", ";", "Changed", "|=", "convertToHardwareLoop", "(", "L", ")", ";", "delete", "FL", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "MBBI", "!=", "E", ")", "{", "MachineBasicBlock", "::", "iterator", "NMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoFrepInfer", ")", "MBBI", "->", "removeFromParent", "(", ")", ";", "MBBI", "=", "NMBBI", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "RI5CY", "\"------------ Snitch Frep Loops ------------\\n\"", "RISCV", "RISCV", "RISCV::PseudoFrepInfer" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getThisReturnPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "nullptr", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_ThisReturn_RegMask", ":", "CSR_AAPCS_ThisReturn_RegMask", ";", "}", "</s>" ]

[ "getThisReturnPreservedMask", "-", "Returns", "a", "call", "preserved", "mask", "specific", "to", "the", "case", "that", "'returned", "'", "is", "on", "an", "i32", "first", "argument", "if", "the", "calling", "convention", "is", "one", "that", "can", "(", "partially", ")", "model", "this", "attribute", "with", "a", "preserved", "mask", "(", "i.e", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "MCStreamer", "&", "Out", ",", "const", "MCInst", "&", "Inst", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

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

[ "Return", "true", "if", "this", "streamer", "supports", "verbose", "assembly", "and", "if", "it", "is", "enabled", "." ]

[ "F2003f" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "MINA32AsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "MINA32", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_u8\"", ",", "0", ",", "8", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "MINA32::NumTargetFixupKinds", "\"fixup_u8\"", "0", "8", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "bool", "visium_legitimate_constant_p", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "constant", "for", "a", "MODE", "immediate", "operand", ".", "X", "is", "guaranteed", "to", "satisfy", "the", "CONSTANT_P", "predicate", "." ]

[ "visium" ]

[]

[ "<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", "||", "arc_check_release31a", "(", "insn", ",", "succ0", ")", ")", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "if", "(", "!", "TARGET_ARC700", ")", "return", ";", "if", "(", "arc_tune", "!=", "ARC_TUNE_ARC7XX", ")", "check_store_cacheline_hazard", "(", ")", ";", "}", "</s>" ]

[ "The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "." ]

[ "arc" ]

[]

[ "<s>", "int", "pdp10_first_parm_offset", "(", ")", "{", "tree", "attr", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "if", "(", "attr", "!=", "NULL_TREE", "&&", "lookup_attribute", "(", "\"noreturn\"", ",", "attr", ")", ")", "return", "0", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Called", "by", "the", "FIRST_PARM_OFFSET", "macro", "." ]

[ "pdp10", "\"noreturn\"", "0", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XtensaFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "assert", "(", "false", "&&", "\"XtensaFrameLowering::eliminateCallFramePseudoInstr\"", "\" not implemented\"", ")", ";", "return", "MBB", ".", "end", "(", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaFrameLowering::eliminateCallFramePseudoInstr\"", "\" not implemented\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isMOVLMask", "(", "M", ",", "VT", ")", "||", "isSHUFPMask", "(", "M", ",", "VT", ")", "||", "isPSHUFDMask", "(", "M", ",", "VT", ")", "||", "isPSHUFHWMask", "(", "M", ",", "VT", ")", "||", "isPSHUFLWMask", "(", "M", ",", "VT", ")", "||", "isUNPCKLMask", "(", "M", ",", "VT", ")", "||", "isUNPCKHMask", "(", "M", ",", "VT", ")", "||", "isUNPCKL_v_undef_Mask", "(", "M", ",", "VT", ")", "||", "isUNPCKH_v_undef_Mask", "(", "M", ",", "VT", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "64", "2", "0" ]

[]

[ "<s>", "unsigned", "postOffset", "(", "Align", "Alignment", "=", "Align", "(", "1", ")", ")", "const", "{", "unsigned", "PO", "=", "Offset", "+", "Size", ";", "const", "Align", "PA", "=", "std", "::", "max", "(", "PostAlign", ",", "Alignment", ")", ";", "if", "(", "PA", "==", "Align", "(", "1", ")", ")", "return", "PO", ";", "return", "PO", "+", "UnknownPadding", "(", "PA", ",", "internalKnownBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Compute", "the", "offset", "immediately", "following", "this", "block", "." ]

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

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "-", "(", "TT", ".", "isOSDarwin", "(", ")", "||", "ReserveX18", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "32", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "32", "AArch64::FPR128_loRegClassID", "16" ]

[]

[ "<s>", "static", "scalar_int_mode", "avr_addr_space_address_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addrspace", "[", "as", "]", ".", "pointer_size", "==", "3", "?", "PSImode", ":", "HImode", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_ADDRESS_MODE", "'", "." ]

[ "avr", "3" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectSize", "(", "FrameIdx", ")", ">=", "RC", "->", "getSize", "(", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "RC", "->", "getSize", "(", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "TM", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "16" ]

[]

[ "<s>", "static", "void", "push", "(", "int", "rn", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "rn", ")", ";", "rtx", "x", ";", "if", "(", "TARGET_H8300", ")", "x", "=", "gen_push_h8300", "(", "reg", ")", ";", "else", "if", "(", "!", "TARGET_NORMAL_MODE", ")", "x", "=", "gen_push_h8300hs_advanced", "(", "reg", ")", ";", "else", "x", "=", "gen_push_h8300hs_normal", "(", "reg", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "REG_NOTES", "(", "x", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "0", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "push", "register", "RN", "onto", "the", "stack", "." ]

[ "h8300", "0" ]

[]

[ "<s>", "int", "getCallFrameSize", "(", ")", "override", "final", "{", "return", "SystemZMC", "::", "ELFCallFrameSize", ";", "}", "</s>" ]

[ "Return", "the", "call", "frame", "size", "on", "entry", "to", "this", "basic", "block", "." ]

[ "SystemZ", "SystemZMC::ELFCallFrameSize" ]

[]

[ "<s>", "void", "RISCVTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "bool", "UseDefaultPreferences", "=", "true", ";", "if", "(", "ST", "->", "getProcFamily", "(", ")", "==", "RISCVSubtarget", "::", "SiFive7", ")", "UseDefaultPreferences", "=", "false", ";", "if", "(", "UseDefaultPreferences", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "if", "(", "getBooleanLoopAttribute", "(", "L", ",", "\"llvm.loop.isvectorized\"", ")", ")", "return", ";", "InstructionCost", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ">", "Operands", "(", "I", ".", "operand_values", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "\"llvm.loop.isvectorized\"", "0", "\"Cost of loop: \"", "\"\\n\"", "60", "12" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "SystemZFrameLowering", ">", "SystemZFrameLowering", "::", "create", "(", "const", "SystemZSubtarget", "&", "STI", ")", "{", "if", "(", "STI", ".", "isTargetXPLINK64", "(", ")", ")", "return", "std", "::", "make_unique", "<", "SystemZXPLINKFrameLowering", ">", "(", ")", ";", "return", "std", "::", "make_unique", "<", "SystemZELFFrameLowering", ">", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "ia64_mangle_type", "(", "const_tree", "type", ")", "{", "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "VOID_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "BOOLEAN_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "REAL_TYPE", ")", "return", "NULL", ";", "if", "(", "!", "TARGET_HPUX", "&&", "TYPE_MODE", "(", "type", ")", "==", "TFmode", ")", "return", "\"g\"", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "XFmode", ")", "return", "TARGET_HPUX", "?", "\"u9__float80\"", ":", "\"e\"", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "RFmode", ")", "return", "\"u7__fpreg\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "mangling", "of", "TYPE", "if", "it", "is", "an", "extended", "fundamental", "type", "." ]

[ "ia64", "\"g\"", "\"u9__float80\"", "\"e\"", "\"u7__fpreg\"" ]

[]

[ "<s>", "const", "MipsMCExpr", "*", "MipsMCExpr", "::", "Create", "(", "MCSymbolRefExpr", "::", "VariantKind", "VK", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "VariantKind", "Kind", ";", "switch", "(", "VK", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_LO", ":", "Kind", "=", "VK_Mips_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_HI", ":", "Kind", "=", "VK_Mips_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_HIGHER", ":", "Kind", "=", "VK_Mips_HIGHER", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_HIGHEST", ":", "Kind", "=", "VK_Mips_HIGHEST", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_IJMP_HI", ":", "Kind", "=", "VK_Mips_IJMP_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_IJMP_LO", ":", "Kind", "=", "VK_Mips_IJMP_LO", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid kind!\"", ")", ";", "}", "return", "new", "(", "Ctx", ")", "MipsMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid kind!\"", "Mips" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AVR", "::", "STDPtrQRr", ":", "case", "AVR", "::", "STDWPtrQRr", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::STDPtrQRr", "AVR::STDWPtrQRr", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "rtx", "avr_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "const", "char", "*", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "unsigned", "int", "id", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "avr_builtin_description", "*", "d", "=", "&", "avr_bdesc", "[", "id", "]", ";", "tree", "arg0", ";", "rtx", "op0", ";", "gcc_assert", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", ";", "switch", "(", "id", ")", "{", "case", "AVR_BUILTIN_NOP", ":", "emit_insn", "(", "gen_nopv", "(", "GEN_INT", "(", "1", ")", ")", ")", ";", "return", "0", ";", "case", "AVR_BUILTIN_DELAY_CYCLES", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_delay_cycles", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_INSERT_BITS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "{", "error", "(", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", ",", "bname", ")", ";", "return", "target", ";", "}", "break", ";", "}", "case", "AVR_BUILTIN_ROUNDHR", ":", "case", "AVR_BUILTIN_ROUNDUHR", ":", "case", "AVR_BUILTIN_ROUNDR", ":", "case", "AVR_BUILTIN_ROUNDUR", ":", "case", "AVR_BUILTIN_ROUNDLR", ":", "case", "AVR_BUILTIN_ROUNDULR", ":", "case", "AVR_BUILTIN_ROUNDLLR", ":", "case", "AVR_BUILTIN_ROUNDULLR", ":", "case", "AVR_BUILTIN_ROUNDHK", ":", "case", "AVR_BUILTIN_ROUNDUHK", ":", "case", "AVR_BUILTIN_ROUNDK", ":", "case", "AVR_BUILTIN_ROUNDUK", ":", "case", "AVR_BUILTIN_ROUNDLK", ":", "case", "AVR_BUILTIN_ROUNDULK", ":", "case", "AVR_BUILTIN_ROUNDLLK", ":", "case", "AVR_BUILTIN_ROUNDULLK", ":", "if", "(", "TREE_CODE", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", "!=", "INTEGER_CST", ")", "break", ";", "int", "rbit", "=", "(", "int", ")", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "rbit", ">=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ")", "{", "warning", "(", "OPT_Wextra", ",", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", ",", "rbit", ",", "GET_MODE_FBIT", "(", "mode", ")", ")", ";", "return", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "if", "(", "rbit", "<=", "-", "(", "int", ")", "GET_MODE_IBIT", "(", "mode", ")", ")", "{", "warning", "(", "0", ",", "\"rounding result will always be 0\"", ")", ";", "return", "CONST0_RTX", "(", "mode", ")", ";", "}", "break", ";", "}", "if", "(", "d", "->", "icode", "==", "CODE_FOR_nothing", "&&", "DECL_ASSEMBLER_NAME", "(", "get_callee_fndecl", "(", "exp", ")", ")", "!=", "NULL_TREE", ")", "{", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "gcc_assert", "(", "d", "->", "icode", "!=", "CODE_FOR_nothing", ")", ";", "gcc_assert", "(", "d", "->", "n_args", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "d", "->", "n_args", "==", "0", ")", "{", "emit_insn", "(", "(", "GEN_FCN", "(", "d", "->", "icode", ")", ")", "(", "target", ")", ")", ";", "return", "NULL_RTX", ";", "}", "return", "avr_default_expand_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "}", "</s>" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "avr", "0", "1", "0", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", "1", "1", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", "0", "0", "\"rounding result will always be 0\"", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "MipsAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createMipsELFObjectWriter", "(", "OS", ",", "TheTriple", ",", "IsN32", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "ARMTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'l'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "else", "weight", "=", "CW_Register", ";", "}", "break", ";", "case", "'w'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "AArch64PostSelectOptimize", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "assert", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Selected", ")", "&&", "\"Expected a selected MF\"", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "MF", ")", "Changed", "|=", "optimizeNZCVDefs", "(", "BB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Expected a selected MF\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasAnyFMA", "(", ")", ")", "return", "false", ";", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "Align", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte stores to stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created store reg=\"", "<<", "printReg", "(", "SrcReg", ",", "TRI", ")", "<<", "\" to FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "ST_rs9", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte stores to stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created store reg=\"", "\" to FrameIndex=\"", "\"\\n\"", "ARC::ST_rs9", "0" ]

[]

[ "<s>", "static", "void", "ia64_h_i_d_extended", "(", "void", ")", "{", "if", "(", "stops_p", "!=", "NULL", ")", "{", "int", "new_clocks_length", "=", "get_max_uid", "(", ")", "*", "3", "/", "2", ";", "stops_p", "=", "(", "char", "*", ")", "xrecalloc", "(", "stops_p", ",", "new_clocks_length", ",", "clocks_length", ",", "1", ")", ";", "clocks_length", "=", "new_clocks_length", ";", "}", "}", "</s>" ]

[ "Implement", "targetm.sched.h_i_d_extended", "hook", ".", "Extend", "internal", "data", "structures", "." ]

[ "ia64", "3", "2", "1" ]

[]

[ "<s>", "void", "s390_expand_vcond", "(", "rtx", "target", ",", "rtx", "then", ",", "rtx", "els", ",", "enum", "rtx_code", "cond", ",", "rtx", "cmp_op1", ",", "rtx", "cmp_op2", ")", "{", "rtx", "tmp", ";", "machine_mode", "result_mode", ";", "rtx", "result_target", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "cmp_mode", "=", "GET_MODE", "(", "cmp_op1", ")", ";", "rtx", "op", "=", "(", "cond", "==", "LT", ")", "?", "els", ":", "then", ";", "if", "(", "(", "cond", "==", "LT", "||", "cond", "==", "GE", ")", "&&", "target_mode", "==", "cmp_mode", "&&", "cmp_op2", "==", "CONST0_RTX", "(", "cmp_mode", ")", "&&", "op", "==", "CONST0_RTX", "(", "target_mode", ")", "&&", "s390_vector_mode_supported_p", "(", "target_mode", ")", "&&", "GET_MODE_CLASS", "(", "target_mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "rtx", "negop", "=", "(", "cond", "==", "LT", ")", "?", "then", ":", "els", ";", "int", "shift", "=", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "target_mode", ")", ")", "-", "1", ";", "if", "(", "negop", "==", "CONST1_RTX", "(", "target_mode", ")", ")", "{", "rtx", "res", "=", "expand_simple_binop", "(", "cmp_mode", ",", "LSHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "else", "if", "(", "all_ones_operand", "(", "negop", ",", "target_mode", ")", ")", "{", "rtx", "res", "=", "expand_simple_binop", "(", "cmp_mode", ",", "ASHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "}", "result_mode", "=", "related_int_vector_mode", "(", "cmp_mode", ")", ".", "require", "(", ")", ";", "result_target", "=", "gen_reg_rtx", "(", "result_mode", ")", ";", "if", "(", "!", "REG_P", "(", "cmp_op1", ")", ")", "cmp_op1", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op1", ")", ",", "cmp_op1", ")", ";", "s390_expand_vec_compare", "(", "result_target", ",", "cond", ",", "cmp_op1", ",", "cmp_op2", ")", ";", "if", "(", "all_ones_operand", "(", "then", ",", "GET_MODE", "(", "then", ")", ")", "&&", "const0_operand", "(", "els", ",", "GET_MODE", "(", "els", ")", ")", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_SUBREG", "(", "target_mode", ",", "result_target", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "!", "REG_P", "(", "then", ")", ")", "then", "=", "force_reg", "(", "target_mode", ",", "then", ")", ";", "if", "(", "!", "REG_P", "(", "els", ")", ")", "els", "=", "force_reg", "(", "target_mode", ",", "els", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "EQ", ",", "VOIDmode", ",", "result_target", ",", "CONST0_RTX", "(", "result_mode", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "target_mode", ",", "tmp", ",", "els", ",", "then", ")", ";", "gcc_assert", "(", "target_mode", "==", "GET_MODE", "(", "then", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "comparison", "expression", "loading", "either", "elements", "of", "THEN", "or", "ELS", "into", "TARGET", "depending", "on", "the", "comparison", "COND", "of", "CMP_OP1", "and", "CMP_OP2", "." ]

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

[]

[ "<s>", "void", "doInitialization", "(", "Module", "&", "M", ")", "{", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "\"RelaxInstruction() unimplemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "AVR", "\"RelaxInstruction() unimplemented\"" ]

[]

[ "<s>", "static", "void", "c6x_init_sched_context", "(", "void", "*", "_sc", ",", "bool", "clean_p", ")", "{", "c6x_sched_context_t", "sc", "=", "(", "c6x_sched_context_t", ")", "_sc", ";", "if", "(", "clean_p", ")", "{", "init_sched_state", "(", "sc", ")", ";", "}", "else", "{", "*", "sc", "=", "ss", ";", "sc", "->", "prev_cycle_state_ctx", "=", "xmalloc", "(", "dfa_state_size", ")", ";", "memcpy", "(", "sc", "->", "prev_cycle_state_ctx", ",", "prev_cycle_state", ",", "dfa_state_size", ")", ";", "}", "}", "</s>" ]

[ "If", "CLEAN_P", "is", "true", "then", "initializes", "_SC", "with", "clean", "data", ",", "and", "from", "the", "global", "context", "otherwise", "." ]

[ "c6x" ]

[]

[ "<s>", "HOST_WIDE_INT", "iq2000_debugger_offset", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "offset2", "=", "const0_rtx", ";", "rtx", "reg", "=", "eliminate_constant_term", "(", "addr", ",", "&", "offset2", ")", ";", "if", "(", "offset", "==", "0", ")", "offset", "=", "INTVAL", "(", "offset2", ")", ";", "if", "(", "reg", "==", "stack_pointer_rtx", "||", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "hard_frame_pointer_rtx", ")", "{", "HOST_WIDE_INT", "frame_size", "=", "(", "!", "cfun", "->", "machine", "->", "initialized", ")", "?", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ":", "cfun", "->", "machine", "->", "total_size", ";", "offset", "=", "offset", "-", "frame_size", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "The", "arg", "pointer", "(", "which", "is", "eliminated", ")", "points", "to", "the", "virtual", "frame", "pointer", ",", "while", "the", "frame", "pointer", "(", "which", "may", "be", "eliminated", ")", "points", "to", "the", "stack", "pointer", "after", "the", "initial", "adjustments", "." ]

[ "iq2000", "0" ]

[]

[ "<s>", "const", "TriCoreRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "SP", "::", "I64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDXri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "FPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "DFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "QFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDQFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::LDXri", "0", "SP::IntRegsRegClass", "SP::LDri", "0", "SP::FPRegsRegClass", "SP::LDFri", "0", "SP::DFPRegsRegClass", "SP::LDDFri", "0", "SP::QFPRegsRegClass", "SP::LDQFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "bool", "hasUsableDivScaleConditionOutput", "(", ")", "const", "{", "return", "getGeneration", "(", ")", "!=", "SOUTHERN_ISLANDS", ";", "}", "</s>" ]

[ "Condition", "output", "from", "div_scale", "is", "usable", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AArch64MIPeepholeOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected to be run on SSA form!\"", ")", ";", "bool", "Changed", "=", "false", ";", "SmallSetVector", "<", "MachineInstr", "*", ",", "8", ">", "ToBeRemoved", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "ANDWrr", ":", "Changed", "=", "visitAND", "<", "uint32_t", ">", "(", "AArch64", "::", "ANDWri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ANDXrr", ":", "Changed", "=", "visitAND", "<", "uint64_t", ">", "(", "AArch64", "::", "ANDXri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ORRWrs", ":", "Changed", "=", "visitORR", "(", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ADDWrr", ":", "Changed", "=", "visitADDSUB", "<", "uint32_t", ">", "(", "AArch64", "::", "ADDWri", ",", "AArch64", "::", "SUBWri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "SUBWrr", ":", "Changed", "=", "visitADDSUB", "<", "uint32_t", ">", "(", "AArch64", "::", "SUBWri", ",", "AArch64", "::", "ADDWri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ADDXrr", ":", "Changed", "=", "visitADDSUB", "<", "uint64_t", ">", "(", "AArch64", "::", "ADDXri", ",", "AArch64", "::", "SUBXri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "SUBXrr", ":", "Changed", "=", "visitADDSUB", "<", "uint64_t", ">", "(", "AArch64", "::", "SUBXri", ",", "AArch64", "::", "ADDXri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "ToBeRemoved", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"Expected to be run on SSA form!\"", "8", "AArch64::ANDWrr", "AArch64::ANDWri", "AArch64::ANDXrr", "AArch64::ANDXri", "AArch64::ORRWrs", "AArch64::ADDWrr", "AArch64::ADDWri", "AArch64::SUBWri", "AArch64::SUBWrr", "AArch64::SUBWri", "AArch64::ADDWri", "AArch64::ADDXrr", "AArch64::ADDXri", "AArch64::SUBXri", "AArch64::SUBXrr", "AArch64::SUBXri", "AArch64::ADDXri" ]

[]

[ "<s>", "static", "rtx", "riscv_split_integer", "(", "HOST_WIDE_INT", "val", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "loval", "=", "sext_hwi", "(", "val", ",", "32", ")", ";", "unsigned", "HOST_WIDE_INT", "hival", "=", "sext_hwi", "(", "(", "val", "-", "loval", ")", ">>", "32", ",", "32", ")", ";", "rtx", "hi", "=", "gen_reg_rtx", "(", "mode", ")", ",", "lo", "=", "gen_reg_rtx", "(", "mode", ")", ";", "riscv_move_integer", "(", "hi", ",", "hi", ",", "hival", ",", "mode", ",", "FALSE", ")", ";", "riscv_move_integer", "(", "lo", ",", "lo", ",", "loval", ",", "mode", ",", "FALSE", ")", ";", "hi", "=", "gen_rtx_fmt_ee", "(", "ASHIFT", ",", "mode", ",", "hi", ",", "GEN_INT", "(", "32", ")", ")", ";", "hi", "=", "force_reg", "(", "mode", ",", "hi", ")", ";", "return", "gen_rtx_fmt_ee", "(", "PLUS", ",", "mode", ",", "hi", ",", "lo", ")", ";", "}", "</s>" ]

[ "Try", "to", "split", "a", "64b", "integer", "into", "32b", "parts", ",", "then", "reassemble", "." ]

[ "riscv", "32", "32", "32", "32" ]

[]

[ "<s>", "static", "section", "*", "pa_function_section", "(", "tree", "decl", ",", "enum", "node_frequency", "freq", ",", "bool", "startup", ",", "bool", "exit", ")", "{", "if", "(", "!", "targetm_common", ".", "have_named_sections", ")", "return", "text_section", ";", "if", "(", "decl", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "==", "NULL", "&&", "DECL_CONTEXT", "(", "decl", ")", "!=", "NULL_TREE", "&&", "TREE_CODE", "(", "DECL_CONTEXT", "(", "decl", ")", ")", "==", "FUNCTION_DECL", "&&", "DECL_SECTION_NAME", "(", "DECL_CONTEXT", "(", "decl", ")", ")", "==", "NULL", ")", "return", "function_section", "(", "DECL_CONTEXT", "(", "decl", ")", ")", ";", "return", "default_function_section", "(", "decl", ",", "freq", ",", "startup", ",", "exit", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "function_section", "." ]

[ "pa" ]

[]

[ "<s>", "void", "PPCHazardRecognizer970", "::", "Reset", "(", ")", "{", "LastWasBL8_ELF", "=", "false", ";", "EndDispatchGroup", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "riscv_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "riscv_arg_info", "info", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "NULL", ";", "return", "riscv_get_arg_info", "(", "&", "info", ",", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "inline", "bool", "is_float128_p", "(", "tree", "t", ")", "{", "return", "(", "t", "==", "float128_type_node", "||", "(", "TARGET_IEEEQUAD", "&&", "TARGET_LONG_DOUBLE_128", "&&", "t", "==", "long_double_type_node", ")", ")", ";", "}", "</s>" ]

[ "Check", "whether", "the", "type", "of", "an", "argument", ",", "T", ",", "is", "compatible", "with", "a", "type", "ID", "stored", "into", "a", "struct", "altivec_builtin_types", ".", "Integer", "types", "are", "considered", "compatible", ";", "otherwise", ",", "the", "language", "hook", "lang_hooks.types_compatible_p", "makes", "the", "decision", ".", "Also", "allow", "long", "double", "and", "_Float128", "to", "be", "compatible", "if", "-mabi=ieeelongdouble", "." ]

[ "rs6000" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "Fast", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "!", "IsMemset", "&&", "Size", ">=", "16", "&&", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f128", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "return", "MVT", "::", "f128", ";", "if", "(", "Size", ">=", "8", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "8", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "i64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "return", "MVT", "::", "i64", ";", "if", "(", "Size", ">=", "4", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "4", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "i32", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "return", "MVT", "::", "i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "AArch64", "AArch64", "16", "16", "MVT::f128", "0", "1", "MVT::f128", "8", "8", "MVT::i64", "0", "1", "MVT::i64", "4", "4", "MVT::i32", "0", "1", "MVT::i32", "MVT::Other" ]

[]

[ "<s>", "void", "SystemZMCAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "BitSize", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ";", "unsigned", "Size", "=", "(", "BitSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "Value", "=", "extractBitsForFixup", "(", "Kind", ",", "Value", ")", ";", "if", "(", "BitSize", "<", "64", ")", "Value", "&=", "(", "(", "uint64_t", ")", "1", "<<", "BitSize", ")", "-", "1", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*", "8", ")", "-", "8", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "Size", ";", "++", "I", ")", "{", "Data", "[", "Offset", "+", "I", "]", "|=", "uint8_t", "(", "Value", ">>", "ShiftValue", ")", ";", "ShiftValue", "-=", "8", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "7", "8", "\"Invalid fixup offset!\"", "64", "1", "1", "8", "8", "0", "8" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "LowerFormalArguments_AIX", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "if", "(", "Subtarget", ".", "is64BitELFABI", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "assert", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", ")", ";", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg" ]

[]

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

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

[ "P2", "P2" ]

[]

[ "<s>", "const", "RegisterBank", "&", "ARMRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "ARM", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "GPRRegClassID", ":", "case", "GPRwithAPSRRegClassID", ":", "case", "GPRnopcRegClassID", ":", "case", "rGPRRegClassID", ":", "case", "GPRspRegClassID", ":", "case", "tGPR_and_tcGPRRegClassID", ":", "case", "tcGPRRegClassID", ":", "case", "tGPRRegClassID", ":", "case", "tGPREvenRegClassID", ":", "case", "tGPROddRegClassID", ":", "case", "tGPR_and_tGPREvenRegClassID", ":", "case", "tGPR_and_tGPROddRegClassID", ":", "case", "tGPREven_and_tcGPRRegClassID", ":", "case", "tGPREven_and_tGPR_and_tcGPRRegClassID", ":", "case", "tGPROdd_and_tcGPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "GPRRegBankID", ")", ";", "case", "HPRRegClassID", ":", "case", "SPR_8RegClassID", ":", "case", "SPRRegClassID", ":", "case", "DPR_8RegClassID", ":", "case", "DPRRegClassID", ":", "case", "QPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "FPRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported register kind\"", ")", ";", "}", "llvm_unreachable", "(", "\"Switch should handle all register classes\"", ")", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegBankID", "ARM::FPRRegBankID", "\"Unsupported register kind\"", "\"Switch should handle all register classes\"" ]

[]

[ "<s>", "InstructionCost", "HexagonTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "ICA", ".", "getID", "(", ")", "==", "Intrinsic", "::", "bswap", ")", "{", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", ".", "getTypeLegalizationCost", "(", "DL", ",", "ICA", ".", "getReturnType", "(", ")", ")", ";", "return", "LT", ".", "first", "+", "2", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "Hexagon", "Hexagon", "Intrinsic::bswap", "2" ]

[]

[ "<s>", "void", "avr_init_expanders", "(", "void", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "32", ";", "regno", "++", ")", "all_regs_rtx", "[", "regno", "]", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "lpm_reg_rtx", "=", "all_regs_rtx", "[", "LPM_REGNO", "]", ";", "tmp_reg_rtx", "=", "all_regs_rtx", "[", "AVR_TMP_REGNO", "]", ";", "zero_reg_rtx", "=", "all_regs_rtx", "[", "AVR_ZERO_REGNO", "]", ";", "lpm_addr_reg_rtx", "=", "gen_rtx_REG", "(", "HImode", ",", "REG_Z", ")", ";", "sreg_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "sreg", ")", ")", ";", "rampd_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampd", ")", ")", ";", "rampx_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampx", ")", ")", ";", "rampy_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampy", ")", ")", ";", "rampz_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "xstring_empty", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"\"", ")", ";", "xstring_e", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"e\"", ")", ";", "if", "(", "AVR_TINY", ")", "avr_have_dimode", "=", "false", ";", "}", "</s>" ]

[ "The", "function", "works", "like", "a", "singleton", "." ]

[ "avr", "0", "32", "\"\"", "\"e\"" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR", ";", "else", "if", "(", "PPC", "::", "G8RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR8", ";", "else", "if", "(", "PPC", "::", "F4RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "FMR", ";", "else", "if", "(", "PPC", "::", "CRRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "MCRF", ";", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "VOR", ";", "else", "if", "(", "PPC", "::", "CRBITRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "CROR", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "const", "TargetInstrDesc", "&", "TID", "=", "get", "(", "Opc", ")", ";", "if", "(", "TID", ".", "getNumOperands", "(", ")", "==", "3", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TID", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TID", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::GPRCRegClass", "PPC::OR", "PPC::G8RCRegClass", "PPC::OR8", "PPC::F4RCRegClass", "PPC::FMR", "PPC::CRRCRegClass", "PPC::MCRF", "PPC::VRRCRegClass", "PPC::VOR", "PPC::CRBITRCRegClass", "PPC::CROR", "\"Impossible reg-to-reg copy\"", "3" ]

[]

[ "<s>", "void", "Thumb1FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "Thumb1InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Thumb1InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "Thumb1RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "Thumb1RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "Amount", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "ARM", "0", "0", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_riscv_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_pcrel_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_i\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_s\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_jal\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_branch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_jump\"", ",", "2", ",", "11", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_branch\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_relax\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_align\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "RISCV", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "RISCV", "\"fixup_riscv_hi20\"", "12", "20", "0", "\"fixup_riscv_lo12_i\"", "20", "12", "0", "\"fixup_riscv_lo12_s\"", "0", "32", "0", "\"fixup_riscv_pcrel_hi20\"", "12", "20", "\"fixup_riscv_pcrel_lo12_i\"", "20", "12", "\"fixup_riscv_pcrel_lo12_s\"", "0", "32", "\"fixup_riscv_jal\"", "12", "20", "\"fixup_riscv_branch\"", "0", "32", "\"fixup_riscv_rvc_jump\"", "2", "11", "\"fixup_riscv_rvc_branch\"", "0", "16", "\"fixup_riscv_call\"", "0", "64", "\"fixup_riscv_relax\"", "0", "0", "0", "\"fixup_riscv_align\"", "0", "0", "0", "RISCV::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "void", "permute_load", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "mem_op", "=", "SET_SRC", "(", "body", ")", ";", "rtx", "tgt_reg", "=", "SET_DEST", "(", "body", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "tgt_reg", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "half_elts", "=", "n_elts", "/", "2", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "n_elts", ")", ")", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ",", "j", "=", "half_elts", ";", "i", "<", "half_elts", ";", "++", "i", ",", "++", "j", ")", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "j", ")", ";", "for", "(", "i", "=", "half_elts", ",", "j", "=", "0", ";", "j", "<", "half_elts", ";", "++", "i", ",", "++", "j", ")", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "j", ")", ";", "rtx", "sel", "=", "gen_rtx_VEC_SELECT", "(", "mode", ",", "mem_op", ",", "par", ")", ";", "SET_SRC", "(", "body", ")", "=", "sel", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Replacing load %d with permuted load\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Convert", "the", "non-permuting", "load", "INSN", "to", "a", "permuting", "one", "." ]

[ "powerpcspe", "2", "0", "0", "0", "0", "1", "\"Replacing load %d with permuted load\\n\"" ]

[]

[ "<s>", "void", "NodeBase", "::", "append", "(", "NodeAddr", "<", "NodeBase", "*", ">", "NA", ")", "{", "NodeId", "Nx", "=", "Next", ";", "if", "(", "Next", "!=", "NA", ".", "Id", ")", "{", "Next", "=", "NA", ".", "Id", ";", "NA", ".", "Addr", "->", "Next", "=", "Nx", ";", "}", "}", "</s>" ]

[ "Append", "from", "a", "list", "of", "StringRefs", "." ]

[ "Hexagon" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "DAG", "->", "addMutation", "(", "createLoadClusterDAGMutation", "(", "DAG", "->", "TII", ",", "DAG", "->", "TRI", ")", ")", ";", "DAG", "->", "addMutation", "(", "ST", ".", "createFillMFMAShadowMutation", "(", "DAG", "->", "TII", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "JVMPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "}", "</s>" ]

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

[ "JVM", "JVM" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "char", "Letter", ",", "bool", "hasMemory", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "0", ",", "0", ")", ";", "switch", "(", "Letter", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "{", "ConstantSDNode", "*", "CST", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ";", "if", "(", "!", "CST", ")", "return", ";", "unsigned", "Value", "=", "CST", "->", "getZExtValue", "(", ")", ";", "switch", "(", "Letter", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown constraint letter!\"", ")", ";", "case", "'I'", ":", "if", "(", "(", "short", ")", "Value", "==", "(", "int", ")", "Value", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'J'", ":", "case", "'L'", ":", "if", "(", "(", "short", ")", "Value", "==", "0", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'K'", ":", "if", "(", "(", "Value", ">>", "16", ")", "==", "0", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'M'", ":", "if", "(", "Value", ">", "31", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'N'", ":", "if", "(", "(", "int", ")", "Value", ">", "0", "&&", "isPowerOf2_32", "(", "Value", ")", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'O'", ":", "if", "(", "Value", "==", "0", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'P'", ":", "if", "(", "(", "short", ")", "-", "Value", "==", "(", "int", ")", "-", "Value", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "break", ";", "}", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Letter", ",", "hasMemory", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "PowerPC", "PPC", "0", "0", "\"Unknown constraint letter!\"", "0", "16", "0", "31", "0", "0" ]

[]

[ "<s>", "static", "bool", "mips_expand_vpc_loongson_pshufh", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "mask", ";", "rtx", "rmask", ";", "if", "(", "!", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ")", "return", "false", ";", "if", "(", "d", "->", "vmode", "!=", "V4HImode", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "for", "(", "i", "=", "mask", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "mask", "|=", "(", "d", "->", "perm", "[", "i", "]", "&", "3", ")", "<<", "(", "i", "*", "2", ")", ";", "rmask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "mask", ")", ")", ";", "if", "(", "d", "->", "one_vector_p", ")", "emit_insn", "(", "gen_loongson_pshufh", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "rmask", ")", ")", ";", "else", "{", "rtx", "t0", ",", "t1", ",", "x", ",", "merge", ",", "rmerge", "[", "4", "]", ";", "t0", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "t1", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "emit_insn", "(", "gen_loongson_pshufh", "(", "t1", ",", "d", "->", "op1", ",", "rmask", ")", ")", ";", "emit_insn", "(", "gen_loongson_pshufh", "(", "t0", ",", "d", "->", "op0", ",", "rmask", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "rmerge", "[", "i", "]", "=", "(", "d", "->", "perm", "[", "i", "]", "&", "4", "?", "constm1_rtx", ":", "const0_rtx", ")", ";", "merge", "=", "gen_rtx_CONST_VECTOR", "(", "V4HImode", ",", "gen_rtvec_v", "(", "4", ",", "rmerge", ")", ")", ";", "merge", "=", "force_reg", "(", "V4HImode", ",", "merge", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "merge", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t1", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "V4HImode", ",", "merge", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "x", ",", "t0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t0", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "V4HImode", ",", "t0", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "d", "->", "target", ",", "x", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "Loongson", "PSHUFH", "instruction", "." ]

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

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "RISCVMachineFunctionInfo", "*", "RVFI", "=", "MF", "->", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "bool", "isRISCVVector", "=", "false", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "LW", ":", "RISCV", "::", "LD", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLD", ";", "else", "if", "(", "RISCV", "::", "VRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "RISCV", "::", "VL1RE8_V", ";", "isRISCVVector", "=", "true", ";", "}", "else", "if", "(", "RISCV", "::", "VRM2RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "RISCV", "::", "VL2RE8_V", ";", "isRISCVVector", "=", "true", ";", "}", "else", "if", "(", "RISCV", "::", "VRM4RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "RISCV", "::", "VL4RE8_V", ";", "isRISCVVector", "=", "true", ";", "}", "else", "if", "(", "RISCV", "::", "VRM8RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "RISCV", "::", "VL8RE8_V", ";", "isRISCVVector", "=", "true", ";", "}", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "if", "(", "isRISCVVector", ")", "{", "RVFI", "->", "setHasSpillVRs", "(", ")", ";", "MFI", ".", "setStackID", "(", "FI", ",", "TargetStackID", "::", "RISCVVector", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::LW", "RISCV::LD", "RISCV::FPR32RegClass", "RISCV::FLW", "RISCV::FPR64RegClass", "RISCV::FLD", "RISCV::VRRegClass", "RISCV::VL1RE8_V", "RISCV", "RISCV::VRM2RegClass", "RISCV::VL2RE8_V", "RISCV", "RISCV::VRM4RegClass", "RISCV::VL4RE8_V", "RISCV", "RISCV::VRM8RegClass", "RISCV::VL8RE8_V", "RISCV", "\"Can't load this register from stack slot\"", "RISCV", "RISCV", "0" ]

[]

[ "<s>", "void", "mmix_setup_frame_addresses", "(", "void", ")", "{", "}", "</s>" ]

[ "SETUP_FRAME_ADDRESSES", "." ]

[ "mmix" ]

[]

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

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

[ "AGC" ]

[]