Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "poly_uint16", "riscv_convert_vector_bits", "(", "void", ")", "{", "if", "(", "TARGET_MIN_VLEN", ">", "32", ")", "{", "riscv_bytes_per_vector_chunk", "=", "8", ";", "}", "else", "{", "riscv_bytes_per_vector_chunk", "=", "4", ";", "}", "return", "TARGET_VECTOR", "?", "poly_uint16", "(", "1", ",", "1", ")", ":", "1", ";", "}", "</s>" ]

[ "Return", "the", "VLEN", "value", "associated", "with", "-march", ".", "TODO", ":", "So", "far", "we", "only", "support", "length-agnostic", "value", "." ]

[ "riscv", "32", "8", "4", "1", "1", "1" ]

[]

[ "<s>", "void", "MipsTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\".sdata\"", "\".sbss\"", "Mips" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "O", "<<", "'['", ";", "printMemOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "']'", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createSIPrepareScratchRegs", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Register", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "getGlobalBaseRegClass", "(", "MF", ")", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "Thumb2HazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "ITBlockSize", ")", "{", "--", "ITBlockSize", ";", "}", "else", "if", "(", "Opcode", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumTZ", "=", "CountTrailingZeros_32", "(", "Mask", ")", ";", "assert", "(", "NumTZ", "<=", "3", "&&", "\"Invalid IT mask!\"", ")", ";", "ITBlockSize", "=", "4", "-", "NumTZ", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "ITBlockSize", ";", "++", "i", ")", "{", "do", "{", "++", "I", ";", "}", "while", "(", "I", "->", "isDebugValue", "(", ")", ")", ";", "ITBlockMIs", "[", "ITBlockSize", "-", "1", "-", "i", "]", "=", "&", "*", "I", ";", "}", "}", "PostRAHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::t2IT", "1", "3", "\"Invalid IT mask!\"", "4", "0", "1" ]

[]

[ "<s>", "bool", "M680x0PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createM680x0ISelDag", "(", "getM680x0TargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createM680x0GlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "M680x0", "M680x0" ]

[]

[ "<s>", "static", "int", "arc_attr_type", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", ":", "JUMP_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ":", "!", "CALL_P", "(", "insn", ")", ")", "return", "-", "1", ";", "return", "get_attr_type", "(", "insn", ")", ";", "}", "</s>" ]

[ "Return", "the", "integer", "value", "of", "the", "``", "type", "''", "attribute", "for", "INSN", ",", "or", "-1", "if", "INSN", "ca", "n't", "have", "attributes", "." ]

[ "arc", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "RISCVTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'r'", ":", "if", "(", "Subtarget", ".", "isRV64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "GR64BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "GR32BitRegClass", ")", ";", "case", "'f'", ":", "if", "(", "Subtarget", ".", "hasD", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "FP64BitRegClass", ")", ";", "else", "if", "(", "Subtarget", ".", "hasF", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "FP32BitRegClass", ")", ";", "else", "if", "(", "Subtarget", ".", "isRV64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "GR64BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "GR32BitRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "1", "0", "0U", "RISCV::GR64BitRegClass", "0U", "RISCV::GR32BitRegClass", "0U", "RISCV::FP64BitRegClass", "0U", "RISCV::FP32BitRegClass", "0U", "RISCV::GR64BitRegClass", "0U", "RISCV::GR32BitRegClass" ]

[]

[ "<s>", "void", "RV16KFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "RV16KRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LastFrameDestroy", "=", "MBBI", ";", "std", "::", "advance", "(", "LastFrameDestroy", ",", "-", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "RV16K", "\"frame pointer should not have been eliminated\"" ]

[]

[ "<s>", "void", "SIMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint64_t", "Encoding", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "bytes", "=", "Desc", ".", "getSize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "bytes", ";", "i", "++", ")", "{", "OS", ".", "write", "(", "(", "uint8_t", ")", "(", "(", "Encoding", ">>", "(", "8", "*", "i", ")", ")", "&", "0xff", ")", ")", ";", "}", "if", "(", "bytes", ">", "4", ")", "return", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "!", "isSrcOperand", "(", "Desc", ",", "i", ")", ")", "continue", ";", "int", "RCID", "=", "Desc", ".", "OpInfo", "[", "i", "]", ".", "RegClass", ";", "const", "MCRegisterClass", "&", "RC", "=", "MRI", ".", "getRegClass", "(", "RCID", ")", ";", "const", "MCOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "getLitEncoding", "(", "Op", ",", "RC", ".", "getSize", "(", ")", ")", "!=", "255", ")", "continue", ";", "int64_t", "Imm", "=", "0", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "else", "if", "(", "Op", ".", "isExpr", "(", ")", ")", "{", "if", "(", "const", "MCConstantExpr", "*", "C", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ")", "Imm", "=", "C", "->", "getValue", "(", ")", ";", "}", "else", "if", "(", "!", "Op", ".", "isExpr", "(", ")", ")", "llvm_unreachable", "(", "\"Must be immediate or expr\"", ")", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "4", ";", "j", "++", ")", "{", "OS", ".", "write", "(", "(", "uint8_t", ")", "(", "(", "Imm", ">>", "(", "8", "*", "j", ")", ")", "&", "0xff", ")", ")", ";", "}", "break", ";", "}", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "AMDGPU", "SI", "0", "8", "0xff", "4", "0", "255", "0", "\"Must be immediate or expr\"", "0", "4", "8", "0xff" ]

[]

[ "<s>", "bool", "ix86_gpr_tls_address_pattern_p", "(", "rtx", "mem", ")", "{", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "rtx", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "addr", ",", "ALL", ")", "{", "rtx", "op", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "op", ",", "1", ")", ")", "{", "case", "UNSPEC_GOTNTPOFF", ":", "return", "true", ";", "case", "UNSPEC_TPOFF", ":", "if", "(", "!", "TARGET_64BIT", ")", "return", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "TLS", "address", "requires", "insn", "using", "integer", "registers", ".", "It", "'s", "used", "to", "prevent", "KMOV/VMOV", "in", "TLS", "code", "sequences", "which", "require", "integer", "MOV", "instructions", ",", "refer", "to", "PR103275", "." ]

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

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "GuaranteedTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "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", ")", "." ]

[ "PowerPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "16", "0xFFFF" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "RC", "==", "&", "X86", "::", "GR8_NOREXRegClass", ")", "return", "RC", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "X86", "::", "FR32RegClassID", ":", "case", "X86", "::", "FR64RegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "getRegSizeInBits", "(", "*", "Super", ")", "==", "getRegSizeInBits", "(", "*", "RC", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "VR128RegClassID", ":", "case", "X86", "::", "VR256RegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasVLX", "(", ")", "&&", "getRegSizeInBits", "(", "*", "Super", ")", "==", "getRegSizeInBits", "(", "*", "RC", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "VR128XRegClassID", ":", "case", "X86", "::", "VR256XRegClassID", ":", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", "&&", "getRegSizeInBits", "(", "*", "Super", ")", "==", "getRegSizeInBits", "(", "*", "RC", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "FR32XRegClassID", ":", "case", "X86", "::", "FR64XRegClassID", ":", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "getRegSizeInBits", "(", "*", "Super", ")", "==", "getRegSizeInBits", "(", "*", "RC", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "GR8RegClassID", ":", "case", "X86", "::", "GR16RegClassID", ":", "case", "X86", "::", "GR32RegClassID", ":", "case", "X86", "::", "GR64RegClassID", ":", "case", "X86", "::", "RFP32RegClassID", ":", "case", "X86", "::", "RFP64RegClassID", ":", "case", "X86", "::", "RFP80RegClassID", ":", "case", "X86", "::", "VR512RegClassID", ":", "if", "(", "getRegSizeInBits", "(", "*", "Super", ")", "==", "getRegSizeInBits", "(", "*", "RC", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "X86", "X86", "X86::GR8_NOREXRegClass", "X86", "X86", "X86::FR32RegClassID", "X86::FR64RegClassID", "X86::VR128RegClassID", "X86::VR256RegClassID", "X86::VR128XRegClassID", "X86::VR256XRegClassID", "X86::FR32XRegClassID", "X86::FR64XRegClassID", "X86::GR8RegClassID", "X86::GR16RegClassID", "X86::GR32RegClassID", "X86::GR64RegClassID", "X86::RFP32RegClassID", "X86::RFP64RegClassID", "X86::RFP80RegClassID", "X86::VR512RegClassID" ]

[]

[ "<s>", "static", "tree", "ix86_handle_cconv_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "METHOD_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "FIELD_DECL", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "TYPE_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "if", "(", "is_attribute_p", "(", "\"regparm\"", ",", "name", ")", ")", "{", "tree", "cst", ";", "if", "(", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"fastcall and regparm attributes are not compatible\"", ")", ";", "}", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "cst", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute requires an integer constant argument\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "compare_tree_int", "(", "cst", ",", "REGPARM_MAX", ")", ">", "0", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument to %qs attribute larger than %d\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ",", "REGPARM_MAX", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute ignored\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "if", "(", "is_attribute_p", "(", "\"fastcall\"", ",", "name", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"cdecl\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"fastcall and cdecl attributes are not compatible\"", ")", ";", "}", "if", "(", "lookup_attribute", "(", "\"stdcall\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"fastcall and stdcall attributes are not compatible\"", ")", ";", "}", "if", "(", "lookup_attribute", "(", "\"regparm\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"fastcall and regparm attributes are not compatible\"", ")", ";", "}", "}", "else", "if", "(", "is_attribute_p", "(", "\"stdcall\"", ",", "name", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"cdecl\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"stdcall and cdecl attributes are not compatible\"", ")", ";", "}", "if", "(", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"stdcall and fastcall attributes are not compatible\"", ")", ";", "}", "}", "else", "if", "(", "is_attribute_p", "(", "\"cdecl\"", ",", "name", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"stdcall\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"stdcall and cdecl attributes are not compatible\"", ")", ";", "}", "if", "(", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"fastcall and cdecl attributes are not compatible\"", ")", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "``", "cdecl", "''", ",", "``", "stdcall", "''", ",", "``", "fastcall", "''", ",", "``", "regparm", "''", "and", "``", "sseregparm", "''", "calling", "convention", "attributes", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "i386", "\"%qs attribute only applies to functions\"", "\"regparm\"", "\"fastcall\"", "\"fastcall and regparm attributes are not compatible\"", "\"%qs attribute requires an integer constant argument\"", "0", "\"argument to %qs attribute larger than %d\"", "\"%qs attribute ignored\"", "\"fastcall\"", "\"cdecl\"", "\"fastcall and cdecl attributes are not compatible\"", "\"stdcall\"", "\"fastcall and stdcall attributes are not compatible\"", "\"regparm\"", "\"fastcall and regparm attributes are not compatible\"", "\"stdcall\"", "\"cdecl\"", "\"stdcall and cdecl attributes are not compatible\"", "\"fastcall\"", "\"stdcall and fastcall attributes are not compatible\"", "\"cdecl\"", "\"stdcall\"", "\"stdcall and cdecl attributes are not compatible\"", "\"fastcall\"", "\"fastcall and cdecl attributes are not compatible\"" ]

[]

[ "<s>", "void", "split_double_mode", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "machine_mode", "half_mode", ";", "unsigned", "int", "byte", ";", "rtx", "mem_op", "=", "NULL_RTX", ";", "int", "mem_num", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "E_TImode", ":", "half_mode", "=", "DImode", ";", "break", ";", "case", "E_DImode", ":", "half_mode", "=", "SImode", ";", "break", ";", "case", "E_P2HImode", ":", "half_mode", "=", "HImode", ";", "break", ";", "case", "E_P2QImode", ":", "half_mode", "=", "QImode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "byte", "=", "GET_MODE_SIZE", "(", "half_mode", ")", ";", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "{", "if", "(", "mem_op", "&&", "rtx_equal_p", "(", "op", ",", "mem_op", ")", ")", "{", "lo_half", "[", "num", "]", "=", "lo_half", "[", "mem_num", "]", ";", "hi_half", "[", "num", "]", "=", "hi_half", "[", "mem_num", "]", ";", "}", "else", "{", "mem_op", "=", "op", ";", "mem_num", "=", "num", ";", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "half_mode", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "half_mode", ",", "byte", ")", ";", "}", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "half_mode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "mode", ":", "GET_MODE", "(", "op", ")", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "half_mode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "mode", ":", "GET_MODE", "(", "op", ")", ",", "byte", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "double-mode", "RTL", "references", "into", "pairs", "of", "half-mode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "double-mode", "RTLs", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

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

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "is", "(", "k_Token", ")", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "MOS" ]

[]

[ "<s>", "bool", "avoid_collisions_1", "(", "const", "rtx", "&", "t", ",", "insn_info_list_t", "*", "v", ",", "tag_map_t", "*", "tag_map", ")", "{", "if", "(", "v", "->", "length", "(", ")", "<", "2", ")", "return", "true", ";", "tag_insn_info", "*", "vec_start", "=", "v", "->", "pop", "(", ")", ";", "tag_insn_info", "*", "insn_info", "=", "vec_start", ";", "do", "{", "int", "new_regno", ";", "if", "(", "(", "new_regno", "=", "rename_dest", "(", "insn_info", ",", "*", "tag_map", ")", ")", "!=", "-", "1", ")", "{", "rtx", "new_tag", "=", "GEN_INT", "(", "TAG_UPDATE_DEST", "(", "INTVAL", "(", "t", ")", ",", "new_regno", ")", ")", ";", "tag_map", "->", "get_or_insert", "(", "new_tag", ")", ".", "safe_push", "(", "insn_info", ")", ";", "df_set_regs_ever_live", "(", "new_regno", ",", "true", ")", ";", "map_changed", "=", "true", ";", "return", "false", ";", "}", "v", "->", "safe_insert", "(", "0", ",", "insn_info", ")", ";", "insn_info", "=", "v", "->", "pop", "(", ")", ";", "}", "while", "(", "insn_info", "!=", "vec_start", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\t>> Failed to rename destination in insn %d\\n\\t>>\"", ",", "INSN_UID", "(", "insn_info", "->", "insn", ")", ")", ";", "delete", "insn_info", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "actual", "reallocation", "logic", ".", "For", "each", "vector", "of", "collisions", "V", ",", "try", "to", "resolve", "the", "collision", "by", "attempting", "to", "rename", "the", "destination", "register", "of", "all", "but", "one", "of", "the", "loads", ".", "This", "is", "a", "callback", "that", "is", "invoked", "for", "each", "name-value", "pair", "(", "T", ",", "V", ")", "in", "TAG_MAP", ".", "The", "function", "returns", "true", "whenever", "it", "returns", "unchanged", "and", "false", "otherwise", "to", "halt", "traversal", "." ]

[ "aarch64", "2", "1", "0", "\"\\t>> Failed to rename destination in insn %d\\n\\t>>\"" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "static", "int", "mips_sched_reassociation_width", "(", "unsigned", "int", "opc", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "2", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_REASSOCIATION_WIDTH", "." ]

[ "mips", "2", "1" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "if", "(", "Subtarget", ".", "enableLongBranchPass", "(", ")", ")", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", "||", "Subtarget", ".", "allowMixed16_32", "(", ")", ")", "addPass", "(", "createMipsConstantIslandPass", "(", "TM", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createMipsNaClRewritePass", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "aarch64_split_simd_combine", "(", "rtx", "dst", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src1", ")", ";", "machine_mode", "dst_mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "dst_mode", ")", ")", ";", "gcc_assert", "(", "register_operand", "(", "dst", ",", "dst_mode", ")", "&&", "register_operand", "(", "src1", ",", "src_mode", ")", "&&", "register_operand", "(", "src2", ",", "src_mode", ")", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "src_mode", ")", "{", "case", "E_V8QImode", ":", "gen", "=", "gen_aarch64_simd_combinev8qi", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_aarch64_simd_combinev4hi", ";", "break", ";", "case", "E_V2SImode", ":", "gen", "=", "gen_aarch64_simd_combinev2si", ";", "break", ";", "case", "E_V4HFmode", ":", "gen", "=", "gen_aarch64_simd_combinev4hf", ";", "break", ";", "case", "E_V2SFmode", ":", "gen", "=", "gen_aarch64_simd_combinev2sf", ";", "break", ";", "case", "E_DImode", ":", "gen", "=", "gen_aarch64_simd_combinedi", ";", "break", ";", "case", "E_DFmode", ":", "gen", "=", "gen_aarch64_simd_combinedf", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "src1", ",", "src2", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Split", "a", "complex", "SIMD", "combine", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "s390_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "size", ">", "8", ")", "return", "true", ";", "if", "(", "type", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "exact_log2", "(", "size", ")", "<", "0", ")", "return", "1", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "a", "function", "argument", "of", "type", "TYPE", "and", "mode", "MODE", "is", "to", "be", "passed", "by", "reference", ".", "The", "ABI", "specifies", "that", "only", "structures", "of", "size", "1", ",", "2", ",", "4", ",", "or", "8", "bytes", "are", "passed", "by", "value", ",", "all", "other", "structures", "(", "and", "complex", "numbers", ")", "are", "passed", "by", "reference", "." ]

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

[]

[ "<s>", "static", "void", "push_minipool_barrier", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ")", "{", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}", "</s>" ]

[ "Record", "that", "there", "is", "a", "natural", "barrier", "in", "the", "insn", "stream", "at", "ADDRESS", "." ]

[ "arm" ]

[]

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

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

[ "MCS51", "MCS51" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", "->", "getSize", "(", ")", "==", "1", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPRd", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "1", "\"Invalid register size\"", "AVR::POPRd" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "if", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getScratchRSrcReg", "(", ")", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getFrameOffsetReg", "(", ")", "!=", "AMDGPU", "::", "FP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getScratchWaveOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", ")", "{", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", ",", "Info", "->", "getScratchWaveOffsetReg", "(", ")", ")", ";", "}", "Info", "->", "limitOccupancy", "(", "MF", ")", ";", "if", "(", "ST", ".", "isWave32", "(", ")", "&&", "!", "MF", ".", "empty", "(", ")", ")", "{", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstNonDebugInstr", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ")", ",", "AMDGPU", "::", "VCC_HI", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "TII", "->", "fixImplicitOperands", "(", "MI", ")", ";", "}", "}", "}", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::SP_REG", "AMDGPU::SP_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::FP_REG", "AMDGPU::FP_REG", "AMDGPU::SCRATCH_WAVE_OFFSET_REG", "AMDGPU::SCRATCH_WAVE_OFFSET_REG", "SI", "AMDGPU::VCC_HI" ]

[]

[ "<s>", "void", "pdp10_init_builtins", "(", ")", "{", "builtin_function", "(", "\"__builtin_fsc\"", ",", "FUNTYPE2", "(", "FLOAT", ",", "FLOAT", ",", "INT", ")", ",", "PDP10_BUILTIN_FSC", ",", "BUILT_IN_MD", ",", "0", ")", ";", "builtin_function", "(", "\"__builtin_dfsc\"", ",", "FUNTYPE2", "(", "DOUBLE", ",", "DOUBLE", ",", "INT", ")", ",", "PDP10_BUILTIN_DFSC", ",", "BUILT_IN_MD", ",", "0", ")", ";", "if", "(", "HAVE_JFFO", ")", "{", "builtin_function", "(", "\"__builtin_jffo\"", ",", "FUNTYPE2", "(", "VOID", ",", "LONGLONG", ",", "VOIDP", ")", ",", "PDP10_BUILTIN_JFFO", ",", "BUILT_IN_MD", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Called", "by", "the", "MD_INIT_BUILTINS", "macro", ".", "Performs", "the", "necessary", "setup", "for", "machine-specific", "builtin", "functions", "." ]

[ "pdp10", "\"__builtin_fsc\"", "0", "\"__builtin_dfsc\"", "0", "\"__builtin_jffo\"", "0" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "LRUsed", "=", "MRI", ".", "isPhysRegModified", "(", "XCore", "::", "LR", ")", ";", "if", "(", "!", "LRUsed", "&&", "!", "MF", ".", "getFunction", "(", ")", "->", "isVarArg", "(", ")", "&&", "MF", ".", "getFrameInfo", "(", ")", "->", "estimateStackSize", "(", "MF", ")", ")", "LRUsed", "=", "true", ";", "if", "(", "MF", ".", "getMMI", "(", ")", ".", "callsUnwindInit", "(", ")", "||", "MF", ".", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "{", "XFI", "->", "createEHSpillSlot", "(", "MF", ")", ";", "LRUsed", "=", "true", ";", "}", "if", "(", "LRUsed", ")", "{", "SavedRegs", ".", "reset", "(", "XCore", "::", "LR", ")", ";", "XFI", "->", "createLRSpillSlot", "(", "MF", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "XFI", "->", "createFPSpillSlot", "(", "MF", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::LR" ]

[]

[ "<s>", "void", "SICFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SICFunctionInfo", "*", "SICFI", "=", "MF", ".", "getInfo", "<", "SICFunctionInfo", ">", "(", ")", ";", "const", "SICInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SICInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SICRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "SICRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "SICABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "SIC", "::", "X", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "SIC", "::", "GPROutRegClass", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "-", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "SIC", "SIC", "\"Shrink-wrapping not yet supported\"", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC::X", "SIC::GPROutRegClass", "0" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "AAPTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "1", "0" ]

[]

[ "<s>", "static", "int", "ia64_adjust_cost_2", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type1", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "dw_t", "dw", ")", "{", "enum", "reg_note", "dep_type", "=", "(", "enum", "reg_note", ")", "dep_type1", ";", "enum", "attr_itanium_class", "dep_class", ";", "enum", "attr_itanium_class", "insn_class", ";", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "dep_class", "=", "ia64_safe_itanium_class", "(", "dep_insn", ")", ";", "if", "(", "dep_type", "==", "REG_DEP_TRUE", "&&", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "&&", "(", "insn_class", "==", "ITANIUM_CLASS_BR", "||", "insn_class", "==", "ITANIUM_CLASS_SCALL", ")", ")", "return", "0", ";", "if", "(", "dw", "==", "MIN_DEP_WEAK", ")", "return", "PARAM_VALUE", "(", "PARAM_SCHED_MEM_TRUE_DEP_COST", ")", ";", "else", "if", "(", "dw", ">", "MIN_DEP_WEAK", ")", "{", "if", "(", "mflag_sched_fp_mem_deps_zero_cost", "&&", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "return", "0", ";", "else", "return", "cost", ";", "}", "if", "(", "dep_type", "!=", "REG_DEP_OUTPUT", ")", "return", "cost", ";", "if", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", "||", "insn_class", "==", "ITANIUM_CLASS_ST", "||", "insn_class", "==", "ITANIUM_CLASS_STF", ")", "return", "0", ";", "return", "cost", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "of", "type", "DEP_TYPE", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", ",", "DW", "is", "dependency", "weakness", "." ]

[ "ia64", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMLowOverheadLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "const", "ARMSubtarget", "&", "ST", "=", "mf", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "MF", "=", "&", "mf", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops on \"", "<<", "MF", "->", "getName", "(", ")", "<<", "\" ------------- \\n\"", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "RDA", "=", "&", "getAnalysis", "<", "ReachingDefAnalysis", ">", "(", ")", ";", "MF", "->", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "*", "MF", ")", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "BBUtils", "->", "adjustBBOffsetsAfter", "(", "&", "MF", "->", "front", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "ML", ":", "*", "MLI", ")", "{", "if", "(", "ML", "->", "isOutermost", "(", ")", ")", "Changed", "|=", "ProcessLoop", "(", "ML", ")", ";", "}", "Changed", "|=", "RevertNonLoops", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"ARM Loops on \"", "\" ------------- \\n\"", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "int64_t", "SIRegisterInfo", "::", "getFrameIndexInstrOffset", "(", "const", "MachineInstr", "*", "MI", ",", "int", "Idx", ")", "const", "{", "if", "(", "!", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "0", ";", "assert", "(", "Idx", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", "&&", "\"Should never see frame index on non-address operand\"", ")", ";", "return", "getMUBUFInstrOffset", "(", "MI", ")", ";", "}", "</s>" ]

[ "Get", "the", "offset", "from", "the", "referenced", "frame", "index", "in", "the", "instruction", ",", "if", "there", "is", "one", "." ]

[ "AMDGPU", "SI", "SI", "0", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "\"Should never see frame index on non-address operand\"" ]

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ",", "bool", "IsTop", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ",", "IsTop", ")", "||", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "LLVM_DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]

[ "Keep", "track", "of", "available", "resources", "." ]

[ "Hexagon", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"" ]

[]

[ "<s>", "bool", "MSP430FrameInfo", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "ISD::FrameIndex", "ISD::BRCOND", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI" ]

[]

[ "<s>", "llvm", "::", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"microMIPS instruction size reduction pass\"", ";", "}", "</s>" ]

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

[ "Mips", "\"microMIPS instruction size reduction pass\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "VT1", ".", "isVector", "(", ")", "||", "VT2", ".", "isVector", "(", ")", "||", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "uint64_t", "NumBits1", "=", "VT1", ".", "getFixedSizeInBits", "(", ")", ";", "uint64_t", "NumBits2", "=", "VT2", ".", "getFixedSizeInBits", "(", ")", ";", "return", "NumBits1", ">", "NumBits2", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "AArch64", "AArch64" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "closeLastSection", "(", ")", "{", "if", "(", "HasSections", ")", "getStreamer", "(", ")", ".", "EmitRawText", "(", "\"\\t}\"", ")", ";", "}", "</s>" ]

[ "Close", "last", "section", "." ]

[ "NVPTX", "NVPTX", "\"\\t}\"" ]

[]

[ "<s>", "DecodeStatus", "PPCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Inst", "=", "IsLittleEndian", "?", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ":", "support", "::", "endian", "::", "read32be", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureQPX", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableQPX32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "4", "4", "0", "support::endian", "support::endian", "PPC::FeatureQPX" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "SICAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "SIC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_SIC_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_SIC_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_SIC_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_SIC_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_SIC_GOT\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_SIC_PC16\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_SIC_PC24\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_SIC_CALL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_SIC_GOT_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_SIC_GOT_LO16\"", ",", "0", ",", "16", ",", "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", "." ]

[ "SIC", "SIC", "SIC::NumTargetFixupKinds", "\"fixup_SIC_32\"", "0", "32", "0", "\"fixup_SIC_HI16\"", "0", "16", "0", "\"fixup_SIC_LO16\"", "0", "16", "0", "\"fixup_SIC_GPREL16\"", "0", "16", "0", "\"fixup_SIC_GOT\"", "0", "16", "0", "\"fixup_SIC_PC16\"", "0", "16", "\"fixup_SIC_PC24\"", "0", "24", "\"fixup_SIC_CALL16\"", "0", "16", "0", "\"fixup_SIC_GOT_HI16\"", "0", "16", "0", "\"fixup_SIC_GOT_LO16\"", "0", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "bool", "isF128SoftLibCall", "(", "const", "char", "*", "CallSym", ")", "{", "const", "char", "*", "const", "LibCalls", "[", "]", "=", "{", "\"__addtf3\"", ",", "\"__divtf3\"", ",", "\"__eqtf2\"", ",", "\"__extenddftf2\"", ",", "\"__extendsftf2\"", ",", "\"__fixtfdi\"", ",", "\"__fixtfsi\"", ",", "\"__fixtfti\"", ",", "\"__fixunstfdi\"", ",", "\"__fixunstfsi\"", ",", "\"__fixunstfti\"", ",", "\"__floatditf\"", ",", "\"__floatsitf\"", ",", "\"__floattitf\"", ",", "\"__floatunditf\"", ",", "\"__floatunsitf\"", ",", "\"__floatuntitf\"", ",", "\"__getf2\"", ",", "\"__gttf2\"", ",", "\"__letf2\"", ",", "\"__lttf2\"", ",", "\"__multf3\"", ",", "\"__netf2\"", ",", "\"__powitf2\"", ",", "\"__subtf3\"", ",", "\"__trunctfdf2\"", ",", "\"__trunctfsf2\"", ",", "\"__unordtf2\"", ",", "\"ceill\"", ",", "\"copysignl\"", ",", "\"cosl\"", ",", "\"exp2l\"", ",", "\"expl\"", ",", "\"floorl\"", ",", "\"fmal\"", ",", "\"fmodl\"", ",", "\"log10l\"", ",", "\"log2l\"", ",", "\"logl\"", ",", "\"nearbyintl\"", ",", "\"powl\"", ",", "\"rintl\"", ",", "\"sinl\"", ",", "\"sqrtl\"", ",", "\"truncl\"", "}", ";", "const", "char", "*", "const", "*", "End", "=", "LibCalls", "+", "array_lengthof", "(", "LibCalls", ")", ";", "MipsTargetLowering", "::", "LTStr", "Comp", ";", "for", "(", "const", "char", "*", "const", "*", "I", "=", "LibCalls", ";", "I", "<", "End", "-", "1", ";", "++", "I", ")", "assert", "(", "Comp", "(", "*", "I", ",", "*", "(", "I", "+", "1", ")", ")", ")", ";", "return", "std", "::", "binary_search", "(", "LibCalls", ",", "End", ",", "CallSym", ",", "Comp", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "CallSym", "is", "a", "long", "double", "emulation", "routine", "." ]

[ "Mips", "\"__addtf3\"", "\"__divtf3\"", "\"__eqtf2\"", "\"__extenddftf2\"", "\"__extendsftf2\"", "\"__fixtfdi\"", "\"__fixtfsi\"", "\"__fixtfti\"", "\"__fixunstfdi\"", "\"__fixunstfsi\"", "\"__fixunstfti\"", "\"__floatditf\"", "\"__floatsitf\"", "\"__floattitf\"", "\"__floatunditf\"", "\"__floatunsitf\"", "\"__floatuntitf\"", "\"__getf2\"", "\"__gttf2\"", "\"__letf2\"", "\"__lttf2\"", "\"__multf3\"", "\"__netf2\"", "\"__powitf2\"", "\"__subtf3\"", "\"__trunctfdf2\"", "\"__trunctfsf2\"", "\"__unordtf2\"", "\"ceill\"", "\"copysignl\"", "\"cosl\"", "\"exp2l\"", "\"expl\"", "\"floorl\"", "\"fmal\"", "\"fmodl\"", "\"log10l\"", "\"log2l\"", "\"logl\"", "\"nearbyintl\"", "\"powl\"", "\"rintl\"", "\"sinl\"", "\"sqrtl\"", "\"truncl\"", "Mips", "1", "1" ]

[]

[ "<s>", "static", "bool", "ck803_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "SET", ":", "if", "(", "MEM_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "struct", "csky_address", "op1", ";", "bool", "address_valid", "=", "decompose_csky_address", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "&", "op1", ")", ";", "if", "(", "op1", ".", "index", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "true", ";", "}", "else", "if", "(", "address_valid", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "}", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", ")", ")", "{", "rtx", "sub_exp", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "sub_exp", ",", "0", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "sub_exp", ",", "1", ")", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "case", "MULT", ":", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "val", "%", "2", "==", "0", "&&", "val", "<", "0xffffffff", "&&", "val", ">", "0", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "TARGET_RTX_COSTS", "helper", "for", "ck803", "." ]

[ "csky", "1", "1", "0", "3", "1", "0", "1", "1", "0", "1", "1", "0", "1", "1", "2", "0", "0xffffffff", "0", "1", "3" ]

[]

[ "<s>", "static", "int", "rs6000_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", "||", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", ")", "{", "reg_class_t", "rclass", "=", "from", ";", "if", "(", "!", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", "rclass", "=", "to", ";", "if", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "ALTIVEC_REGS", "||", "rclass", "==", "VSX_REGS", ")", "ret", "=", "(", "rs6000_memory_move_cost", "(", "mode", ",", "rclass", ",", "false", ")", "+", "rs6000_memory_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "false", ")", ")", ";", "else", "if", "(", "rclass", "==", "CR_REGS", ")", "ret", "=", "4", ";", "else", "if", "(", "(", "rs6000_cpu", "==", "PROCESSOR_POWER6", "||", "rs6000_cpu", "==", "PROCESSOR_POWER7", "||", "rs6000_cpu", "==", "PROCESSOR_POWER8", "||", "rs6000_cpu", "==", "PROCESSOR_POWER9", ")", "&&", "reg_classes_intersect_p", "(", "rclass", ",", "LINK_OR_CTR_REGS", ")", ")", "ret", "=", "6", "*", "hard_regno_nregs", "(", "0", ",", "mode", ")", ";", "else", "ret", "=", "2", "*", "hard_regno_nregs", "(", "0", ",", "mode", ")", ";", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "VSX_REGS", ")", "&&", "reg_classes_intersect_p", "(", "from", ",", "VSX_REGS", ")", ")", "ret", "=", "2", "*", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "mode", ")", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "from", ")", ")", "ret", "=", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "?", "4", ":", "2", ";", "else", "ret", "=", "(", "rs6000_register_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "to", ")", "+", "rs6000_register_move_cost", "(", "mode", ",", "from", ",", "GENERAL_REGS", ")", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "from", "]", ",", "reg_class_names", "[", "to", "]", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "returning", "the", "cost", "of", "moving", "data", "from", "a", "register", "of", "class", "CLASS1", "to", "one", "of", "CLASS2", "." ]

[ "powerpcspe", "4", "6", "0", "2", "0", "2", "4", "2", "1", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"" ]

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW BB#\"", "<<", "BB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", "->", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "postprocessDAG", "(", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ")", "{", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "SchedImpl", "->", "schedNode", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW BB#\"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "8", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"Nonempty unscheduled zone.\"" ]

[]

[ "<s>", "uint64_t", "SystemZMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "uint64_t", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unexpected operand type!\"", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "SystemZ", "SystemZ", "\"Unexpected operand type!\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "bb_first_real_insn", "(", "basic_block", "bb", ")", "{", "rtx_insn", "*", "insn", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "return", "insn", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "first", "real", "insn", "in", "BB", ",", "or", "return", "NULL_RTX", "if", "BB", "does", "not", "contain", "real", "insns", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "bool", "isAtomic", "(", ")", "const", "{", "return", "Ordering", "!=", "AtomicOrdering", "::", "NotAtomic", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operation", "has", "an", "atomic", "ordering", "requirement", "of", "unordered", "or", "higher", ",", "false", "otherwise", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "BitVector", "SPIRVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "BitVector", "(", "getNumRegs", "(", ")", ")", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "const", "char", "*", "nds32_output_stack_pop", "(", "rtx", "par_rtx", "ATTRIBUTE_UNUSED", ")", "{", "char", "pattern", "[", "100", "]", ";", "rtx", "operands", "[", "3", "]", ";", "int", "rb_eh_data", "=", "cfun", "->", "machine", "->", "eh_return_data_first_regno", ";", "int", "re_eh_data", "=", "cfun", "->", "machine", "->", "eh_return_data_last_regno", ";", "int", "first_eh_data_regno", "=", "EH_RETURN_DATA_REGNO", "(", "0", ")", ";", "int", "rb_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_first_gpr_regno", ";", "int", "re_callee_saved", "=", "cfun", "->", "machine", "->", "callee_saved_last_gpr_regno", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "SImode", ",", "first_eh_data_regno", ")", ",", "par_rtx", ")", ")", "{", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "rb_eh_data", ")", ";", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_eh_data", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop.s\\t%s\"", ",", "\"%0, %1, { }\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "if", "(", "NDS32_V3PUSH_AVAILABLE_P", ")", "{", "int", "sp_adjust", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "if", "(", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", "&&", "!", "cfun", "->", "calls_alloca", ")", "operands", "[", "1", "]", "=", "GEN_INT", "(", "sp_adjust", ")", ";", "else", "{", "if", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", "{", "sp_adjust", "=", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "sp_adjust", ")", ";", "}", "else", "{", "operands", "[", "1", "]", "=", "GEN_INT", "(", "0", ")", ";", "}", "}", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop25\\t%%0, %%1\"", ")", ";", "}", "else", "{", "int", "pop_en4_only_p", "=", "0", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "rb_callee_saved", ")", ";", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "fp_size", "&&", "!", "cfun", "->", "machine", "->", "gp_size", "&&", "!", "cfun", "->", "machine", "->", "lp_size", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "SP_REGNUM", ")", "{", "return", "\"\"", ";", "}", "else", "{", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "1", "]", ")", "==", "SP_REGNUM", ")", "pop_en4_only_p", "=", "1", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"pop.s\\t%s{%s%s%s }\"", ",", "pop_en4_only_p", "?", "\"\"", ":", "\"%0, %1, \"", ",", "cfun", "->", "machine", "->", "fp_size", "?", "\" $fp\"", ":", "\"\"", ",", "cfun", "->", "machine", "->", "gp_size", "?", "\" $gp\"", ":", "\"\"", ",", "cfun", "->", "machine", "->", "lp_size", "?", "\" $lp\"", ":", "\"\"", ")", ";", "}", "}", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Function", "to", "output", "stack", "pop", "operation", ".", "We", "need", "to", "deal", "with", "normal", "stack", "pop", "multiple", "or", "stack", "v3pop", "." ]

[ "nds32", "100", "3", "0", "0", "1", "\"pop.s\\t%s\"", "\"%0, %1, { }\"", "\"\"", "0", "1", "1", "1", "0", "\"pop25\\t%%0, %%1\"", "0", "0", "1", "0", "1", "\"\"", "0", "1", "1", "\"pop.s\\t%s{%s%s%s }\"", "\"\"", "\"%0, %1, \"", "\" $fp\"", "\"\"", "\" $gp\"", "\"\"", "\" $lp\"", "\"\"", "\"\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"BPF Assembly Printer\"", ";", "}", "</s>" ]

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

[ "BPF", "\"BPF Assembly Printer\"" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "SubTarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "regFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "nullptr", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "SP", "SP::I6", "SP::CFI_INSTRUCTION", "SP::CFI_INSTRUCTION", "SP::I7", "SP::O7", "SP::CFI_INSTRUCTION" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "Result", ".", "reset", "(", "new", "AMDGPUAAResult", "(", "M", ".", "getDataLayout", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "assert", "(", "ClassID", "==", "GPRRC", "||", "ClassID", "==", "FPRRC", "||", "ClassID", "==", "VRRC", "||", "ClassID", "==", "VSXRC", ")", ";", "if", "(", "ST", "->", "hasVSX", "(", ")", ")", "{", "assert", "(", "ClassID", "==", "GPRRC", "||", "ClassID", "==", "VSXRC", "||", "ClassID", "==", "VRRC", ")", ";", "return", "ClassID", "==", "VSXRC", "?", "64", ":", "32", ";", "}", "assert", "(", "ClassID", "==", "GPRRC", "||", "ClassID", "==", "FPRRC", "||", "ClassID", "==", "VRRC", ")", ";", "return", "32", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "PowerPC", "PPC", "64", "32", "32" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createAMDGPUCFGStructurizerPass", "(", ")", ")", ";", "addPass", "(", "createR600ExpandSpecialInstrsPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "&", "FinalizeMachineBundlesID", ")", ";", "addPass", "(", "createR600Packetizer", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600ControlFlowFinalizer", "(", "*", "TM", ")", ")", ";", "}", "else", "{", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "void", "AArch64PostLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "if", "(", "!", "IsOptNone", ")", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "}", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "rtx", "frv_expand_voidaccop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op2", ";", "rtx", "op3", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "0", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "op1", "=", "frv_int_to_acc", "(", "icode", ",", "1", ",", "op1", ")", ";", "if", "(", "!", "op1", ")", "return", "NULL_RTX", ";", "op2", "=", "frv_matching_accg_for_acc", "(", "op0", ")", ";", "op3", "=", "frv_matching_accg_for_acc", "(", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ",", "op2", ",", "op3", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "perform", "accumulator-to-accumulator", "operations", ".", "These", "builtins", "take", "two", "accumulator", "numbers", "as", "argument", "and", "return", "void", "." ]

[ "frv", "0", "1" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_nop", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "Hexagon", "Hexagon", "Hexagon::A2_nop" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getPrefetchDistance", "(", ")", "const", "{", "return", "getST", "(", ")", "->", "getL1PrefetchDistance", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "prefetch", "distance", "in", "terms", "of", "instructions", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "machine_mode", "s390_tm_ccmode", "(", "rtx", "op1", ",", "rtx", "op2", ",", "bool", "mixed", ")", "{", "int", "bit0", ",", "bit1", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", "||", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", ")", "return", "VOIDmode", ";", "if", "(", "INTVAL", "(", "op2", ")", "==", "0", ")", "return", "CCTmode", ";", "if", "(", "INTVAL", "(", "op2", ")", "==", "INTVAL", "(", "op1", ")", ")", "return", "CCT3mode", ";", "if", "(", "mixed", ")", "{", "bit1", "=", "exact_log2", "(", "INTVAL", "(", "op2", ")", ")", ";", "bit0", "=", "exact_log2", "(", "INTVAL", "(", "op1", ")", "^", "INTVAL", "(", "op2", ")", ")", ";", "if", "(", "bit0", "!=", "-", "1", "&&", "bit1", "!=", "-", "1", ")", "return", "bit0", ">", "bit1", "?", "CCT1mode", ":", "CCT2mode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "If", "a", "test-under-mask", "instruction", "can", "be", "used", "to", "implement", "(", "compare", "(", "and", "...", "OP1", ")", "OP2", ")", ",", "return", "the", "CC", "mode", "required", "to", "do", "that", ".", "Otherwise", ",", "return", "VOIDmode", ".", "MIXED", "is", "true", "if", "the", "instruction", "can", "distinguish", "between", "CC1", "and", "CC2", "for", "mixed", "selected", "bits", "(", "TMxx", ")", ",", "it", "is", "false", "if", "the", "instruction", "can", "not", "(", "TM", ")", "." ]

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

[]

[ "<s>", "bool", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "P2" ]

[]

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

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

[ "Z80", "Z80" ]

[]

[ "<s>", "bool", "ARM64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createARM64BranchRelaxation", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getSubtarget", "<", "ARM64Subtarget", ">", "(", ")", ".", "isTargetMachO", "(", ")", ")", "addPass", "(", "createARM64CollectLOHPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "static", "int", "rs6000_variable_issue_1", "(", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "last_scheduled_insn", "=", "insn", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "{", "cached_can_issue_more", "=", "more", ";", "return", "cached_can_issue_more", ";", "}", "if", "(", "insn_terminates_group_p", "(", "insn", ",", "current_group", ")", ")", "{", "cached_can_issue_more", "=", "0", ";", "return", "cached_can_issue_more", ";", "}", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "more", ";", "if", "(", "rs6000_sched_groups", ")", "{", "if", "(", "is_microcoded_insn", "(", "insn", ")", ")", "cached_can_issue_more", "=", "0", ";", "else", "if", "(", "is_cracked_insn", "(", "insn", ")", ")", "cached_can_issue_more", "=", "more", ">", "2", "?", "more", "-", "2", ":", "0", ";", "else", "cached_can_issue_more", "=", "more", "-", "1", ";", "return", "cached_can_issue_more", ";", "}", "if", "(", "rs6000_cpu_attr", "==", "CPU_CELL", "&&", "is_nonpipeline_insn", "(", "insn", ")", ")", "return", "0", ";", "cached_can_issue_more", "=", "more", "-", "1", ";", "return", "cached_can_issue_more", ";", "}", "</s>" ]

[ "Power4", "load", "update", "and", "store", "update", "instructions", "are", "cracked", "into", "a", "load", "or", "store", "and", "an", "integer", "insn", "which", "are", "executed", "in", "the", "same", "cycle", ".", "Branches", "have", "their", "own", "dispatch", "slot", "which", "does", "not", "count", "against", "the", "GCC", "issue", "rate", ",", "but", "it", "changes", "the", "program", "flow", "so", "there", "are", "no", "other", "instructions", "to", "issue", "in", "this", "cycle", "." ]

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

[]

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

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

[ "ARM", "ARM", "ARM::STR", "ARM::t2STRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::t2STRi12", "ARM::tSpill", "1", "2", "2", "0", "1", "0", "ARM::VSTRD", "ARM::VSTRS", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "SNESAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createSNESELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES" ]

[]

[ "<s>", "static", "MachineInstr", "*", "findLoopInstr", "(", "MachineBasicBlock", "*", "BB", ",", "int", "EndLoopOp", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "&", "Visited", ")", "{", "int", "LOOPi", ";", "int", "LOOPr", ";", "if", "(", "EndLoopOp", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop0i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop0r", ";", "}", "else", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop1i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop1r", ";", "}", "for", "(", "MachineBasicBlock", "::", "pred_iterator", "PB", "=", "BB", "->", "pred_begin", "(", ")", ",", "PE", "=", "BB", "->", "pred_end", "(", ")", ";", "PB", "!=", "PE", ";", "++", "PB", ")", "{", "if", "(", "!", "Visited", ".", "insert", "(", "*", "PB", ")", ".", "second", ")", "continue", ";", "if", "(", "*", "PB", "==", "BB", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "reverse_instr_iterator", "I", "=", "(", "*", "PB", ")", "->", "instr_rbegin", "(", ")", ",", "E", "=", "(", "*", "PB", ")", "->", "instr_rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "LOOPi", "||", "Opc", "==", "LOOPr", ")", "return", "&", "*", "I", ";", "if", "(", "Opc", "==", "EndLoopOp", ")", "return", "0", ";", "}", "MachineInstr", "*", "loop", "=", "findLoopInstr", "(", "*", "PB", ",", "EndLoopOp", ",", "Visited", ")", ";", "if", "(", "loop", ")", "return", "loop", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Hexagon", "8", "Hexagon::ENDLOOP0", "Hexagon::J2_loop0i", "Hexagon::J2_loop0r", "Hexagon::J2_loop1i", "Hexagon::J2_loop1r", "0", "0" ]

[]

[ "<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2022 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcus", "[", "n_mcus", "++", "]", "=", "mcu", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>" ]

[ "Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "." ]

[ "avr", "0", "\"@c Copyright (C) 2012-2022 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\"" ]

[]

[ "<s>", "void", "SystemZFrameInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "const", "SystemZInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "SystemZMFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "SystemZ", "::", "RET", ":", "break", ";", "default", ":", "assert", "(", "0", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", "-", "SystemZMFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "--", "MBBI", ";", "if", "(", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "}", "if", "(", "StackSize", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64rmm", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64rm", ")", "&&", "\"Expected to see callee-save register restore code\"", ")", ";", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "SystemZ", "::", "R15D", ")", "&&", "\"Invalid stack frame calculation!\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isImm", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Unexpected restore code!\"", ")", ";", "}", "uint64_t", "Offset", "=", "NumBytes", "+", "MI", ".", "getOperand", "(", "i", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", ">", "524287", ")", "{", "NumBytes", "=", "Offset", "-", "524287", ";", "Offset", "=", "524287", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "NumBytes", ",", "TII", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::RET", "0", "\"Can only insert epilog into returning blocks\"", "SystemZ", "SystemZ::MOV64rmm", "SystemZ::MOV64rm", "\"Expected to see callee-save register restore code\"", "SystemZ::R15D", "\"Invalid stack frame calculation!\"", "0", "\"Unexpected restore code!\"", "524287", "524287", "524287" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "LDW_RI", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::LDW_RI", "0" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "TII", "->", "legalizeOperands", "(", "MI", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "0", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "0", "1", "0", "0", "4", "1", "1", "0", "1", "2", "3", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "Cpu0MCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "if", "(", "Opcode", "==", "Cpu0", "::", "JSUB", "||", "Opcode", "==", "Cpu0", "::", "JMP", "||", "Opcode", "==", "Cpu0", "::", "BAL", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Cpu0", "::", "fixup_Cpu0_PC24", ")", ")", ")", ";", "else", "llvm_unreachable", "(", "\"unexpect opcode in getJumpAbsoluteTargetOpValue()\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "Cpu0", "Cpu0", "\"getJumpTargetOpValue expects only expressions\"", "Cpu0::JSUB", "Cpu0::JMP", "Cpu0::BAL", "0", "Cpu0::fixup_Cpu0_PC24", "\"unexpect opcode in getJumpAbsoluteTargetOpValue()\"", "0" ]

[]

[ "<s>", "BitVector", "AlphaRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R15", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R31", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::R15", "Alpha::R29", "Alpha::R30", "Alpha::R31" ]

[]

[ "<s>", "SDNode", "*", "WebAssemblyDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "llvm_unreachable", "(", "\"TODO: implement Select\"", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"TODO: implement Select\"" ]

[]

[ "<s>", "void", "c6x_expand_call", "(", "rtx", "retval", ",", "rtx", "address", ",", "bool", "sibcall", ")", "{", "rtx", "callee", "=", "XEXP", "(", "address", ",", "0", ")", ";", "rtx", "call_insn", ";", "if", "(", "!", "c6x_call_operand", "(", "callee", ",", "Pmode", ")", ")", "{", "callee", "=", "force_reg", "(", "Pmode", ",", "callee", ")", ";", "address", "=", "change_address", "(", "address", ",", "Pmode", ",", "callee", ")", ";", "}", "call_insn", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "address", ",", "const0_rtx", ")", ";", "if", "(", "sibcall", ")", "{", "call_insn", "=", "emit_call_insn", "(", "call_insn", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "call_insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "REG_B3", ")", ")", ";", "}", "else", "{", "if", "(", "retval", "==", "NULL_RTX", ")", "call_insn", "=", "emit_call_insn", "(", "call_insn", ")", ";", "else", "call_insn", "=", "emit_call_insn", "(", "gen_rtx_SET", "(", "retval", ",", "call_insn", ")", ")", ";", "}", "if", "(", "flag_pic", ")", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "call_insn", ")", ",", "pic_offset_table_rtx", ")", ";", "}", "</s>" ]

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

[ "c6x", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegToStackSlot - Can't retrieve spilled VGPR!\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "Opcode", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Cannot spill register class\"", ")", ";", "}", "SIMachineFunctionInfo", "::", "SpilledReg", "Spill", "=", "MFI", "->", "SpillTracker", ".", "getSpilledReg", "(", "FrameIndex", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "Spill", ".", "VGPR", ")", ".", "addImm", "(", "FrameIndex", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"VGPR spilling not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "\"SIInstrInfo::loadRegToStackSlot - Can't retrieve spilled VGPR!\"", "0", "8", "32", "SI", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "\"Cannot spill register class\"", "SI", "\"VGPR spilling not supported\"" ]

[]

[ "<s>", "static", "bool", "loop_basic_block_p", "(", "const", "basic_block", "cfg_bb", ")", "{", "if", "(", "JUMP_P", "(", "BB_END", "(", "cfg_bb", ")", ")", "&&", "any_condjump_p", "(", "BB_END", "(", "cfg_bb", ")", ")", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "cfg_bb", "->", "succs", ")", "if", "(", "e", "->", "dest", "->", "index", "==", "cfg_bb", "->", "index", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "block", "is", "a", "loop", "itself", ":", "local_dem", "__________", "____|____", "|", "|", "|", "|", "|________|", "|", "|_________|", "reaching_out" ]

[ "riscv" ]

[]

[ "<s>", "static", "bool", "sparc_strict_argument_naming", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ")", "{", "return", "TARGET_ARCH64", "?", "true", ":", "false", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_STRICT_ARGUMENT_NAMING", "target", "hook", "." ]

[ "sparc" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "unsigned", "NVPTXInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"NVPTX branch conditions have two components!\"", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "NVPTX", "::", "GOTO", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "NVPTX", "::", "CBranch", ")", ")", ".", "addReg", "(", "Cond", "[", "0", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "NVPTX", "::", "CBranch", ")", ")", ".", "addReg", "(", "Cond", "[", "0", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "NVPTX", "::", "GOTO", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "NVPTX", "NVPTX", "\"code size not handled\"", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"NVPTX branch conditions have two components!\"", "NVPTX::GOTO", "NVPTX::CBranch", "0", "1", "NVPTX::CBranch", "0", "NVPTX::GOTO", "2" ]

[]

[ "<s>", "int", "nds32_can_use_btgl_p", "(", "int", "ival", ")", "{", "int", "one_bit_count", ";", "one_bit_count", "=", "popcount_hwi", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "ival", ")", ")", ";", "return", "(", "TARGET_PERF_EXT", "&&", "(", "one_bit_count", "==", "1", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'btgl", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr128", ":", "SPU", "::", "LQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr64", ":", "SPU", "::", "LQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr64", ":", "SPU", "::", "LQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr32", ":", "SPU", "::", "LQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr32", ":", "SPU", "::", "LQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr16", ":", "SPU", "::", "LQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr8", ":", "SPU", "::", "LQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "LQDv16i8", ":", "SPU", "::", "LQXv16i8", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown regclass in loadRegFromStackSlot!\"", ")", ";", "}", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::LQDr128", "SPU::LQXr128", "SPU::R64CRegisterClass", "SPU::LQDr64", "SPU::LQXr64", "SPU::R64FPRegisterClass", "SPU::LQDr64", "SPU::LQXr64", "SPU::R32CRegisterClass", "SPU::LQDr32", "SPU::LQXr32", "SPU::R32FPRegisterClass", "SPU::LQDr32", "SPU::LQXr32", "SPU::R16CRegisterClass", "SPU::LQDr16", "SPU::LQXr16", "SPU::R8CRegisterClass", "SPU::LQDr8", "SPU::LQXr8", "SPU::VECREGRegisterClass", "SPU::LQDv16i8", "SPU::LQXv16i8", "\"Unknown regclass in loadRegFromStackSlot!\"" ]

[]

[ "<s>", "static", "char", "*", "detect_caches_freebsd", "(", "void", ")", "{", "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "size_t", "len", "=", "4", ";", "sysctlbyname", "(", "\"machdep.cacheline_size\"", ",", "&", "l1_line", ",", "&", "len", ",", "NULL", ",", "0", ")", ";", "l1_sizekb", "=", "32", ";", "l1_assoc", "=", "0", ";", "l2_sizekb", "=", "512", ";", "return", "describe_cache", "(", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ")", ";", "}", "</s>" ]

[ "Returns", "the", "description", "of", "caches", "on", "FreeBSD", "PPC", "." ]

[ "powerpcspe", "4", "\"machdep.cacheline_size\"", "0", "32", "0", "512" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vrev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "(", "*", "gen", ")", "(", "machine_mode", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "diff", ")", "{", "case", "7", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev64", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "3", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev32", ";", "break", ";", "case", "E_V8HImode", ":", "case", "E_V4HImode", ":", "case", "E_V8HFmode", ":", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vrev64", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "1", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev16", ";", "break", ";", "case", "E_V8HImode", ":", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vrev32", ";", "break", ";", "case", "E_V4SImode", ":", "case", "E_V2SImode", ":", "case", "E_V4SFmode", ":", "case", "E_V2SFmode", ":", "gen", "=", "gen_neon_vrev64", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "1", ")", "for", "(", "j", "=", "0", ";", "j", "<=", "diff", ";", "j", "+=", "1", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "vmode", ",", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mem_operand_ds_form", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ";", "int", "extra", ";", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "offsettable_address_p", "(", "false", ",", "mode", ",", "addr", ")", ")", "return", "false", ";", "op", "=", "address_offset", "(", "addr", ")", ";", "if", "(", "op", "==", "NULL_RTX", ")", "return", "true", ";", "offset", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "(", "offset", "&", "3", ")", "!=", "0", ")", "return", "false", ";", "extra", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ";", "if", "(", "extra", "<", "0", ")", "extra", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "offset", "=", "(", "(", "offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "return", "offset", "+", "0x8000", "<", "0x10000u", "-", "extra", ";", "}", "</s>" ]

[ "As", "above", ",", "but", "for", "DS-FORM", "VSX", "insns", ".", "Unlike", "mem_operand_gpr", ",", "enforce", "an", "offset", "divisible", "by", "4", "even", "for", "32-bit", "." ]

[ "powerpcspe", "0", "3", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0x8000", "0x10000u" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createMipsELFObjectWriter", "(", "OS", ",", "OSType", ",", "IsLittle", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "PatmosBypassFromPML", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "EnableBypassFromPML", ")", "return", "false", ";", "PMLImport", "&", "PI", "=", "getAnalysis", "<", "PMLImport", ">", "(", ")", ";", "PMLMCQuery", "*", "Query", "=", "PI", ".", "createMCQuery", "(", "*", "this", ",", "MF", ")", ";", "bool", "Changed", "=", "false", ";", "PMLQuery", "::", "ValueFactsMap", "LoadFacts", ";", "if", "(", "Query", "&&", "Query", "->", "getMemFacts", "(", "MF", ",", "LoadFacts", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"[BypassFromPML] \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "MF", ".", "begin", "(", ")", ",", "FE", "=", "MF", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "{", "PMLQuery", "::", "ValueFactList", "&", "VFL", "=", "Query", "->", "getBBMemFacts", "(", "LoadFacts", ",", "*", "FI", ")", ";", "if", "(", "!", "VFL", ".", "empty", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" MBB#\"", "<<", "FI", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ")", ";", "Changed", "|=", "bypassCacheLoads", "(", "*", "FI", ",", "Query", ",", "VFL", ")", ";", "}", "}", "delete", "Query", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"[BypassFromPML] \"", "\"\\n\"", "\" MBB#\"", "\"\\n\"" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", "{", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"sqrtf\"", ",", "true", ",", "1", ")", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"divf\"", ",", "false", ",", "1", ")", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"vec-sqrtf\"", ",", "true", ",", "1", ")", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"vec-divf\"", ",", "true", ",", "1", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

[ "X86", "X86", "X86", "\"sqrtf\"", "1", "\"divf\"", "1", "\"vec-sqrtf\"", "1", "\"vec-divf\"", "1" ]

[]

[ "<s>", "static", "rtx", "arm_expand_builtin_1", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ",", "arm_builtin_datum", "*", "d", ")", "{", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "+", "1", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "bool", "neon", "=", "false", ";", "if", "(", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_VFP_BASE", ",", "ARM_BUILTIN_ACLE_BASE", "-", "1", ")", ")", "neon", "=", "true", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_pair_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_PAIR_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_struct_load_store_lane_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_STRUCT_LOAD_STORE_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "ARG_BUILTIN_CONSTANT", ":", "ARG_BUILTIN_COPY_TO_REG", ";", "}", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_pointer", ")", "{", "if", "(", "neon", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_NEON_MEMORY", ";", "else", "args", "[", "k", "]", "=", "ARG_BUILTIN_MEMORY", ";", "}", "else", "args", "[", "k", "]", "=", "ARG_BUILTIN_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "ARG_BUILTIN_STOP", ";", "return", "arm_expand_builtin_args", "(", "target", ",", "d", "->", "mode", ",", "fcode", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "&", "args", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Expand", "a", "builtin", ".", "These", "builtins", "are", "``", "special", "''", "because", "they", "do", "n't", "have", "symbolic", "constants", "defined", "per-instruction", "or", "per", "instruction-variant", ".", "Instead", ",", "the", "required", "info", "is", "looked", "up", "in", "the", "ARM_BUILTIN_DATA", "record", "that", "is", "passed", "into", "the", "function", "." ]

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

[]

[ "<s>", "const", "char", "*", "LM32TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "LM32ISD", "::", "JmpLink", ":", "return", "\"LM32ISD::JmpLink\"", ";", "case", "LM32ISD", "::", "GPRel", ":", "return", "\"LM32ISD::GPRel\"", ";", "case", "LM32ISD", "::", "ICmp", ":", "return", "\"LM32ISD::ICmp\"", ";", "case", "LM32ISD", "::", "RetFlag", ":", "return", "\"LM32ISD::RetFlag\"", ";", "case", "LM32ISD", "::", "LM32Select_CC", ":", "return", "\"LM32ISD::LM32Select_CC\"", ";", "case", "LM32ISD", "::", "Hi", ":", "return", "\"LM32ISD::Hi\"", ";", "case", "LM32ISD", "::", "Lo", ":", "return", "\"LM32ISD::Lo\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "LM32", "LM32", "LM32ISD::JmpLink", "\"LM32ISD::JmpLink\"", "LM32ISD::GPRel", "\"LM32ISD::GPRel\"", "LM32ISD::ICmp", "\"LM32ISD::ICmp\"", "LM32ISD::RetFlag", "\"LM32ISD::RetFlag\"", "LM32ISD::LM32Select_CC", "\"LM32ISD::LM32Select_CC\"", "LM32ISD::Hi", "\"LM32ISD::Hi\"", "LM32ISD::Lo", "\"LM32ISD::Lo\"" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPARC Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"SPARC Delay Slot Filler\"" ]

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "const", "HexagonEvaluator", "HE", "(", "HRI", ",", "MRI", ",", "HII", ",", "MF", ")", ";", "BitTracker", "BT", "(", "HE", ",", "MF", ")", ";", "DEBUG", "(", "BT", ".", "trace", "(", "true", ")", ")", ";", "BT", ".", "run", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "RegisterSet", "AIG", ";", "ConstGeneration", "ImmG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "ImmG", ",", "AIG", ")", ";", "RegisterSet", "ARE", ";", "RedundantInstrElimination", "RIE", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "bool", "Ried", "=", "visitBlock", "(", "Entry", ",", "RIE", ",", "ARE", ")", ";", "if", "(", "Ried", ")", "{", "Changed", "=", "true", ";", "BT", ".", "run", "(", ")", ";", "}", "RegisterSet", "ACG", ";", "CopyGeneration", "CopyG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyG", ",", "ACG", ")", ";", "RegisterSet", "ACP", ";", "CopyPropagation", "CopyP", "(", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyP", ",", "ACP", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "BT", ".", "run", "(", ")", ";", "RegisterSet", "ABS", ";", "BitSimplification", "BitS", "(", "BT", ",", "HII", ",", "HRI", ",", "MRI", ",", "MF", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "BitS", ",", "ABS", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "if", "(", "Changed", ")", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "I", ".", "clearKillInfo", "(", ")", ";", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "return", "RC", "->", "getNumRegs", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "rtx", "riscv_unspec_address", "(", "rtx", "address", ",", "enum", "riscv_symbol_type", "symbol_type", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "address", ",", "&", "base", ",", "&", "offset", ")", ";", "return", "riscv_unspec_address_offset", "(", "base", ",", "offset", ",", "symbol_type", ")", ";", "}", "</s>" ]

[ "Return", "an", "UNSPEC", "address", "with", "underlying", "address", "ADDRESS", "and", "symbol", "type", "SYMBOL_TYPE", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "AMDGPUPerfHintAnalysis", "::", "runOnSCC", "(", "CallGraphSCC", "&", "SCC", ")", "{", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "CallGraphNode", "*", "I", ":", "SCC", ")", "{", "Function", "*", "F", "=", "I", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "F", "->", "isDeclaration", "(", ")", ")", "continue", ";", "const", "TargetSubtargetInfo", "*", "ST", "=", "TM", ".", "getSubtargetImpl", "(", "*", "F", ")", ";", "AMDGPUPerfHint", "Analyzer", "(", "FIM", ",", "ST", "->", "getTargetLowering", "(", ")", ")", ";", "if", "(", "Analyzer", ".", "runOnFunction", "(", "*", "F", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnSCC", "-", "This", "method", "should", "be", "implemented", "by", "the", "subclass", "to", "perform", "whatever", "action", "is", "necessary", "for", "the", "specified", "SCC", "." ]

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

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "TM", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "RetValue", "=", "convertValVTToLocVT", "(", "DAG", ",", "DL", ",", "VA", ",", "RetValue", ")", ";", "unsigned", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RetValue", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ".", "data", "(", ")", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ", "SystemZISD::RET_FLAG", "MVT::Other", "4", "0", "\"Can only return in registers!\"", "1", "0", "SystemZISD::RET_FLAG", "MVT::Other" ]

[]