Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "int", "m32c_dwarf_frame_regnum", "(", "int", "n", ")", "{", "switch", "(", "n", ")", "{", "case", "R0_REGNO", ":", "return", "5", ";", "case", "R1_REGNO", ":", "return", "6", ";", "case", "R2_REGNO", ":", "return", "7", ";", "case", "R3_REGNO", ":", "return", "8", ";", "case", "A0_REGNO", ":", "return", "9", ";", "case", "A1_REGNO", ":", "return", "10", ";", "case", "FB_REGNO", ":", "return", "11", ";", "case", "SB_REGNO", ":", "return", "19", ";", "case", "SP_REGNO", ":", "return", "12", ";", "case", "PC_REGNO", ":", "return", "13", ";", "default", ":", "return", "DWARF_FRAME_REGISTERS", "+", "1", ";", "}", "}", "</s>" ]

[ "Implements", "DWARF_FRAME_REGNUM", "and", "DEBUGGER_REGNO", ".", "Note", "that", "the", "original", "spec", "called", "for", "dwarf", "numbers", "to", "vary", "with", "register", "width", "as", "well", ",", "for", "example", ",", "r0l", ",", "r0", ",", "and", "r2r0", "would", "each", "have", "different", "dwarf", "numbers", ".", "GCC", "does", "n't", "support", "this", ",", "and", "we", "do", "n't", "do", "it", ",", "and", "gdb", "seems", "to", "like", "it", "this", "way", "anyway", "." ]

[ "m32c", "5", "6", "7", "8", "9", "10", "11", "19", "12", "13", "1" ]

[]

[ "<s>", "static", "rtx", "safe_vector_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "x", "!=", "const0_rtx", ")", "return", "x", ";", "x", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_movsi", "(", "x", ",", "CONST0_RTX", "(", "SImode", ")", ")", ")", ";", "return", "gen_lowpart", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "Errors", "in", "the", "source", "file", "can", "cause", "expand_expr", "to", "return", "const0_rtx", "where", "we", "expect", "a", "vector", ".", "To", "avoid", "crashing", ",", "use", "one", "of", "the", "vector", "clear", "instructions", "." ]

[ "bfin" ]

[]

[ "<s>", "void", "aarch64_save_restore_target_globals", "(", "tree", "new_tree", ")", "{", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "</s>" ]

[ "Restore", "or", "save", "the", "TREE_TARGET_GLOBALS", "from", "or", "to", "NEW_TREE", ".", "Used", "by", "aarch64_set_current_function", "and", "aarch64_pragma_target_parse", "to", "make", "sure", "optab", "availability", "predicates", "are", "recomputed", "when", "necessary", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "RegisterBank", "&", "MipsRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "Mips", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MovePPairFirstRegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16MovePPairSecondRegClassID", ":", "case", "Mips", "::", "GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID", ":", "case", "Mips", "::", "SP32RegClassID", ":", "case", "Mips", "::", "GP32RegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ";", "case", "Mips", "::", "FGRCCRegClassID", ":", "case", "Mips", "::", "FGR32RegClassID", ":", "case", "Mips", "::", "FGR64RegClassID", ":", "case", "Mips", "::", "AFGR64RegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "FPRBRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::GPR32RegClassID", "Mips::CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MovePPairFirstRegClassID", "Mips::CPU16Regs_and_GPRMM16MovePPairSecondRegClassID", "Mips::GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID", "Mips::SP32RegClassID", "Mips::GP32RegClassID", "Mips::GPRBRegBankID", "Mips::FGRCCRegClassID", "Mips::FGR32RegClassID", "Mips::FGR64RegClassID", "Mips::AFGR64RegClassID", "Mips::FPRBRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "void", "LC2200InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "LC2200", "::", "ADD", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "LC2200", "::", "zero", ")", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200::ADD", "LC2200::zero" ]

[]

[ "<s>", "void", "LEGRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "LEG", "::", "LDR", ":", "case", "LEG", "::", "STR", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "LEG", "::", "SP", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "0", "LEG::LDR", "LEG::STR", "1", "LEG::SP" ]

[]

[ "<s>", "static", "parallel", "*", "nvptx_find_par", "(", "bb_insn_map_t", "*", "map", ",", "parallel", "*", "par", ",", "basic_block", "block", ")", "{", "if", "(", "block", "->", "flags", "&", "BB_VISITED", ")", "return", "par", ";", "block", "->", "flags", "|=", "BB_VISITED", ";", "if", "(", "rtx_insn", "*", "*", "endp", "=", "map", "->", "get", "(", "block", ")", ")", "{", "rtx_insn", "*", "end", "=", "*", "endp", ";", "switch", "(", "recog_memoized", "(", "end", ")", ")", "{", "case", "CODE_FOR_return", ":", "return", "par", ";", "case", "CODE_FOR_nvptx_forked", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "mask", ")", ";", "par", "=", "new", "parallel", "(", "par", ",", "mask", ")", ";", "par", "->", "forked_block", "=", "block", ";", "par", "->", "forked_insn", "=", "end", ";", "if", "(", "nvptx_needs_shared_bcast", "(", "mask", ")", ")", "par", "->", "fork_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_fork", ")", ";", "}", "break", ";", "case", "CODE_FOR_nvptx_join", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "par", "->", "mask", "==", "mask", ")", ";", "gcc_assert", "(", "par", "->", "join_block", "==", "NULL", ")", ";", "par", "->", "join_block", "=", "block", ";", "par", "->", "join_insn", "=", "end", ";", "if", "(", "nvptx_needs_shared_bcast", "(", "mask", ")", ")", "par", "->", "joining_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_joining", ")", ";", "par", "=", "par", "->", "parent", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "par", ")", "par", "->", "blocks", ".", "safe_push", "(", "block", ")", ";", "else", "par", "=", "new", "parallel", "(", "0", ",", "0", ")", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "block", "->", "succs", ")", "nvptx_find_par", "(", "map", ",", "par", ",", "e", "->", "dest", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "See", "also", "'gcc/omp-oacc-neuter-broadcast.cc", ":", "omp_sese_find_par", "'", "." ]

[ "nvptx", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "ix86_free_from_memory", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_RED_ZONE", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "DImode", "||", "TARGET_64BIT", ")", "size", "=", "8", ";", "else", "size", "=", "4", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Free", "operand", "from", "the", "memory", "." ]

[ "i386", "8", "4" ]

[]

[ "<s>", "void", "PatmosOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register \"", ";", "OS", "<<", "PatmosInstPrinter", "::", "getRegisterName", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Memory", ":", "{", "OS", "<<", "\"<memory \"", ";", "OS", "<<", "getMemBase", "(", ")", ";", "OS", "<<", "\", \"", ";", "OS", "<<", "getMemOff", "(", ")", ";", "OS", "<<", "\">\"", ";", "}", "break", ";", "}", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"<register \"", "Patmos", "\">\"", "\"'\"", "\"'\"", "\"<memory \"", "\", \"", "\">\"" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", "true", ";", "const", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "!", "Info", "->", "isEntryFunction", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

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

[]

[ "<s>", "SDValue", "M680x0TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "getJumpTableEncoding", "(", ")", "==", "MachineJumpTableInfo", "::", "EK_Custom32", ")", "return", "DAG", ".", "getNode", "(", "M680x0ISD", "::", "GlobalBaseReg", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "M680x0", "M680x0", "M680x0ISD::GlobalBaseReg" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "if", "(", "Is64Bit", ")", "return", "X86", "::", "RIP", ";", "else", "return", "X86", "::", "EIP", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "X86", "X86", "X86::RIP", "X86::EIP" ]

[]

[ "<s>", "void", "ARCAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "O", "(", "Str", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "ARC", "::", "DBG_VALUE", ":", "llvm_unreachable", "(", "\"Should be handled target independently\"", ")", ";", "break", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "128", "ARC::DBG_VALUE", "\"Should be handled target independently\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STRrs", ":", "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", "::", "STRi12", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "tSTRspi", ":", "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", ";", "case", "ARM", "::", "VSTR_P0_off", ":", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "ARM", "::", "P0", ";", "}", "break", ";", "case", "ARM", "::", "VST1q64", ":", "case", "ARM", "::", "VST1d64TPseudo", ":", "case", "ARM", "::", "VST1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VSTMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "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::STRrs", "ARM::t2STRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::STRi12", "ARM::t2STRi12", "ARM::tSTRspi", "ARM::VSTRD", "ARM::VSTRS", "1", "2", "2", "0", "1", "0", "ARM::VSTR_P0_off", "0", "1", "1", "0", "0", "ARM::P0", "ARM::VST1q64", "ARM::VST1d64TPseudo", "ARM::VST1d64QPseudo", "0", "2", "0", "0", "2", "ARM::VSTMQIA", "1", "0", "0", "1", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "int", "rs6000_reg_parm_stack_space", "(", "tree", "fun", ",", "bool", "incoming", ")", "{", "int", "reg_parm_stack_space", ";", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "reg_parm_stack_space", "=", "0", ";", "break", ";", "case", "ABI_AIX", ":", "case", "ABI_DARWIN", ":", "reg_parm_stack_space", "=", "TARGET_64BIT", "?", "64", ":", "32", ";", "break", ";", "case", "ABI_ELFv2", ":", "if", "(", "rs6000_function_parms_need_stack", "(", "fun", ",", "incoming", ")", ")", "reg_parm_stack_space", "=", "TARGET_64BIT", "?", "64", ":", "32", ";", "else", "reg_parm_stack_space", "=", "0", ";", "break", ";", "}", "return", "reg_parm_stack_space", ";", "}", "</s>" ]

[ "Return", "the", "size", "of", "the", "REG_PARM_STACK_SPACE", "are", "for", "FUN", ".", "This", "is", "usually", "a", "constant", "depending", "on", "the", "ABI", ".", "However", ",", "in", "the", "ELFv2", "ABI", "the", "register", "parameter", "area", "is", "optional", "when", "calling", "a", "function", "that", "has", "a", "prototype", "is", "scope", ",", "has", "no", "variable", "argument", "list", ",", "and", "passes", "all", "parameters", "in", "registers", "." ]

[ "powerpcspe", "0", "64", "32", "64", "32", "0" ]

[]

[ "<s>", "static", "reg_class_t", "mn10300_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "enum", "reg_class", "xclass", "=", "NO_REGS", ";", "unsigned", "int", "xregno", "=", "INVALID_REGNUM", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "xregno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "xregno", ">=", "FIRST_PSEUDO_REGISTER", ")", "xregno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "xregno", "!=", "INVALID_REGNUM", ")", "xclass", "=", "REGNO_REG_CLASS", "(", "xregno", ")", ";", "}", "if", "(", "!", "TARGET_AM33", ")", "{", "if", "(", "rclass", "!=", "DATA_REGS", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "xclass", "==", "NO_REGS", ")", "return", "DATA_REGS", ";", "if", "(", "in_p", "&&", "rclass", "==", "SP_REGS", "&&", "xclass", "!=", "ADDRESS_REGS", ")", "return", "ADDRESS_REGS", ";", "if", "(", "!", "in_p", "&&", "xclass", "==", "SP_REGS", "&&", "rclass", "!=", "ADDRESS_REGS", "&&", "rclass", "!=", "SP_OR_ADDRESS_REGS", ")", "return", "ADDRESS_REGS", ";", "}", "if", "(", "in_p", "&&", "rclass", "!=", "SP_REGS", "&&", "rclass", "!=", "SP_OR_ADDRESS_REGS", "&&", "rclass", "!=", "SP_OR_GENERAL_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "(", "XEXP", "(", "x", ",", "0", ")", "==", "stack_pointer_rtx", "||", "XEXP", "(", "x", ",", "1", ")", "==", "stack_pointer_rtx", ")", ")", "{", "sri", "->", "icode", "=", "CODE_FOR_reload_plus_sp_const", ";", "return", "NO_REGS", ";", "}", "if", "(", "rclass", "==", "MDR_REGS", "&&", "xclass", "!=", "DATA_REGS", ")", "return", "DATA_REGS", ";", "if", "(", "xclass", "==", "MDR_REGS", "&&", "rclass", "!=", "DATA_REGS", ")", "return", "DATA_REGS", ";", "if", "(", "TARGET_AM33_2", "&&", "(", "rclass", "==", "FP_REGS", "||", "xclass", "==", "FP_REGS", ")", "&&", "(", "xclass", "==", "NO_REGS", "||", "rclass", "==", "NO_REGS", ")", ")", "{", "rtx", "addr", "=", "NULL", ";", "if", "(", "xregno", ">=", "FIRST_PSEUDO_REGISTER", "&&", "xregno", "!=", "INVALID_REGNUM", ")", "{", "addr", "=", "reg_equiv_mem", "(", "xregno", ")", ";", "if", "(", "addr", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "x", ")", ")", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "addr", "&&", "CONSTANT_ADDRESS_P", "(", "addr", ")", ")", "return", "GENERAL_REGS", ";", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_RELOAD", "." ]

[ "mn10300", "0", "1", "0", "0" ]

[]

[ "<s>", "EVT", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "override", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "RISCV", "MVT::i32" ]

[]

[ "<s>", "machine_mode", "memory_vector_mode", "(", "const", "function_instance", "&", "fi", ")", "const", "OVERRIDE", "{", "poly_uint64", "nunits", "=", "GET_MODE_NUNITS", "(", "fi", ".", "vector_mode", "(", "0", ")", ")", ";", "return", "aarch64_sve_data_mode", "(", "m_to_mode", ",", "nunits", ")", ".", "require", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "a", "vector", "mode", "whose", "GET_MODE_NUNITS", "is", "the", "number", "of", "elements", "addressed", "and", "whose", "GET_MODE_INNER", "is", "the", "mode", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "TeakInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "dbgs", "(", ")", "<<", "\"loadRegFromStackSlot\\n\"", ";", "dbgs", "(", ")", "<<", "\"ICC live: \"", "<<", "MBB", ".", "computeRegisterLiveness", "(", "TRI", ",", "Teak", "::", "ICC", ",", "I", ")", "<<", "\"\\n\"", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "->", "hasSuperClassEq", "(", "&", "Teak", "::", "ABRegsRegClass", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Teak", "::", "LOAD_REG_FROM_STACK_PSEUDO_32_SEXT40", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Teak", "::", "LOAD_REG_FROM_STACK_PSEUDO_16", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "\"loadRegFromStackSlot\\n\"", "\"ICC live: \"", "Teak::ICC", "\"\\n\"", "Teak::ABRegsRegClass", "Teak::LOAD_REG_FROM_STACK_PSEUDO_32_SEXT40", "0", "Teak::LOAD_REG_FROM_STACK_PSEUDO_16", "0" ]

[]

[ "<s>", "bool", "SNESAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Mnemonic", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "SNESOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "bool", "first", "=", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "!", "first", ")", "eatComma", "(", ")", ";", "first", "=", "false", ";", "auto", "MatchResult", "=", "MatchOperandParserImpl", "(", "Operands", ",", "Mnemonic", ")", ";", "if", "(", "MatchResult", "==", "MatchOperand_Success", ")", "{", "continue", ";", "}", "if", "(", "MatchResult", "==", "MatchOperand_ParseFail", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"failed to parse register and immediate pair\"", ")", ";", "}", "if", "(", "parseOperand", "(", "Operands", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNESOperand::CreateToken", "\"failed to parse register and immediate pair\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "void", "ia64_expand_widen_sum", "(", "rtx", "operands", "[", "3", "]", ",", "bool", "unsignedp", ")", "{", "rtx", "l", ",", "h", ",", "x", ",", "s", ";", "enum", "machine_mode", "wmode", ",", "mode", ";", "rtx", "(", "*", "unpack_l", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "unpack_h", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "plus", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "wmode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "mode", "=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ";", "switch", "(", "mode", ")", "{", "case", "V8QImode", ":", "unpack_l", "=", "gen_unpack1_l", ";", "unpack_h", "=", "gen_unpack1_h", ";", "plus", "=", "gen_addv4hi3", ";", "break", ";", "case", "V4HImode", ":", "unpack_l", "=", "gen_unpack2_l", ";", "unpack_h", "=", "gen_unpack2_h", ";", "plus", "=", "gen_addv2si3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "unsignedp", ")", "x", "=", "CONST0_RTX", "(", "mode", ")", ";", "else", "{", "bool", "neg", ";", "x", "=", "gen_reg_rtx", "(", "mode", ")", ";", "neg", "=", "ia64_expand_vecint_compare", "(", "LT", ",", "mode", ",", "x", ",", "operands", "[", "1", "]", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "gcc_assert", "(", "!", "neg", ")", ";", "}", "l", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "h", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "s", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "emit_insn", "(", "unpack_l", "(", "gen_lowpart", "(", "mode", ",", "l", ")", ",", "operands", "[", "1", "]", ",", "x", ")", ")", ";", "emit_insn", "(", "unpack_h", "(", "gen_lowpart", "(", "mode", ",", "h", ")", ",", "operands", "[", "1", "]", ",", "x", ")", ")", ";", "emit_insn", "(", "plus", "(", "s", ",", "l", ",", "operands", "[", "2", "]", ")", ")", ";", "emit_insn", "(", "plus", "(", "operands", "[", "0", "]", ",", "h", ",", "s", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "integral", "vector", "widening", "sum", "operations", "." ]

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

[]

[ "<s>", "bool", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "CSKY" ]

[]

[ "<s>", "bool", "WebAssemblyFixIrreducibleControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Fixing Irreducible Control Flow **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Changed", "=", "false", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "Changed", "|=", "VisitLoop", "(", "MF", ",", "MLI", ",", "nullptr", ")", ";", "SmallVector", "<", "MachineLoop", "*", ",", "8", ">", "Worklist", "(", "MLI", ".", "begin", "(", ")", ",", "MLI", ".", "end", "(", ")", ")", ";", "while", "(", "!", "Worklist", ".", "empty", "(", ")", ")", "{", "MachineLoop", "*", "CurLoop", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "Worklist", ".", "append", "(", "CurLoop", "->", "begin", "(", ")", ",", "CurLoop", "->", "end", "(", ")", ")", ";", "Changed", "|=", "VisitLoop", "(", "MF", ",", "MLI", ",", "CurLoop", ")", ";", "}", "if", "(", "LLVM_UNLIKELY", "(", "Changed", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Recomputing dominators and loops.\\n\"", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ".", "runOnMachineFunction", "(", "MF", ")", ";", "MLI", ".", "runOnMachineFunction", "(", "MF", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Fixing Irreducible Control Flow **********\\n\"", "\"********** Function: \"", "8", "\"Recomputing dominators and loops.\\n\"" ]

[]

[ "<s>", "int", "c4x_U_constraint", "(", "rtx", "op", ")", "{", "return", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ";", "}", "</s>" ]

[ "Symbolic", "operand", "." ]

[ "c4x" ]

[]

[ "<s>", "unsigned", "TOYInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "llvm_unreachable", "(", "\"getGlobalBaseReg not implemented\\n\"", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"getGlobalBaseReg not implemented\\n\"" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "cerr", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "abort", "(", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "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", ")", "." ]

[ "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "static", "rtx", "nds32_expand_cctl_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ",", "bool", "return_p", ",", "const", "char", "*", "name", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "nds32_read_argument", "(", "exp", ",", "0", ")", ";", "rtx", "op1", "=", "nds32_read_argument", "(", "exp", ",", "1", ")", ";", "int", "op0_num", "=", "return_p", "?", "1", ":", "0", ";", "int", "op1_num", "=", "return_p", "?", "2", ":", "1", ";", "if", "(", "return_p", ")", "target", "=", "nds32_legitimize_target", "(", "icode", ",", "target", ")", ";", "if", "(", "!", "nds32_check_constant_argument", "(", "icode", ",", "op0_num", ",", "op0", ",", "name", ")", ")", "return", "NULL_RTX", ";", "op0", "=", "nds32_legitimize_argument", "(", "icode", ",", "op0_num", ",", "op0", ")", ";", "op1", "=", "nds32_legitimize_argument", "(", "icode", ",", "op1_num", ",", "op1", ")", ";", "if", "(", "icode", "==", "CODE_FOR_cctl_idx_write", ")", "{", "rtx", "op2", "=", "nds32_read_argument", "(", "exp", ",", "2", ")", ";", "op2", "=", "nds32_legitimize_argument", "(", "icode", ",", "2", ",", "op2", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ",", "op2", ")", ";", "}", "else", "if", "(", "return_p", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "cctl", "builtins", "." ]

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

[]

[ "<s>", "static", "HOST_WIDE_INT", "s390_vector_alignment", "(", "const_tree", "type", ")", "{", "if", "(", "!", "TARGET_VX_ABI", ")", "return", "default_vector_alignment", "(", "type", ")", ";", "if", "(", "TYPE_USER_ALIGN", "(", "type", ")", ")", "return", "TYPE_ALIGN", "(", "type", ")", ";", "return", "MIN", "(", "64", ",", "tree_to_shwi", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", ";", "}", "</s>" ]

[ "The", "vector", "ABI", "requires", "vector", "types", "to", "be", "aligned", "on", "an", "8", "byte", "boundary", "(", "our", "stack", "alignment", ")", ".", "However", ",", "we", "allow", "this", "to", "be", "overriden", "by", "the", "user", ",", "while", "this", "definitely", "breaks", "the", "ABI", "." ]

[ "s390", "64" ]

[]

[ "<s>", "static", "int", "visium_save_reg_p", "(", "int", "interrupt", ",", "int", "regno", ")", "{", "switch", "(", "regno", ")", "{", "case", "HARD_FRAME_POINTER_REGNUM", ":", "return", "0", ";", "case", "MDC_REGNUM", ":", "break", ";", "case", "29", ":", "case", "30", ":", "return", "(", "interrupt", "!=", "0", ")", ";", "default", ":", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "0", ";", "break", ";", "}", "if", "(", "interrupt", ")", "{", "if", "(", "crtl", "->", "is_leaf", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "1", ";", "}", "else", "if", "(", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "1", ";", "if", "(", "regno", "==", "PROLOGUE_TMP_REGNUM", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "MDB_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "MDC_REGNUM", ")", ")", "return", "1", ";", "for", "(", "int", "i", "=", "FP_FIRST_REGNUM", ";", "i", "<=", "FP_LAST_REGNUM", ";", "i", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "i", ")", ")", "return", "1", ";", "}", "else", "if", "(", "regno", "==", "PROLOGUE_TMP_REGNUM", "+", "1", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "MDB_REGNUM", ")", ")", "return", "1", ";", "}", "}", "return", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "register", "REGNO", "needs", "to", "be", "saved", "in", "the", "frame", "." ]

[ "visium", "0", "29", "30", "0", "0", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "int", "microblaze_interrupt_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "a", "=", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "true", "if", "FUNC", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt_handler", "''", "attribute", "." ]

[ "microblaze", "0", "\"interrupt_handler\"" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Bottom Releasing \"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", ")", ";", "if", "(", "isPhysicalRegCopy", "(", "SU", "->", "getInstr", "(", ")", ")", ")", "{", "PhysicalRegCopy", ".", "push_back", "(", "SU", ")", ";", "return", ";", "}", "int", "IK", "=", "getInstKind", "(", "SU", ")", ";", "for", "(", "MachineInstr", "::", "const_mop_iterator", "I", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_begin", "(", ")", ",", "E", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReg", "(", ")", "&&", "I", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "AR_X", ")", "{", "if", "(", "I", "->", "isDef", "(", ")", ")", "{", "UnscheduledARDefs", ".", "push_back", "(", "SU", ")", ";", "}", "else", "{", "UnscheduledARUses", ".", "push_back", "(", "SU", ")", ";", "}", "return", ";", "}", "}", "if", "(", "IK", "==", "IDOther", ")", "Available", "[", "IDOther", "]", ".", "push_back", "(", "SU", ")", ";", "else", "Pending", "[", "IK", "]", ".", "push_back", "(", "SU", ")", ";", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "R600", "\"Bottom Releasing \"" ]

[]

[ "<s>", "static", "void", "init_dispatch_sched", "(", "void", ")", "{", "dispatch_window_list", "=", "allocate_window", "(", ")", ";", "dispatch_window_list1", "=", "allocate_window", "(", ")", ";", "init_window", "(", "0", ")", ";", "init_window", "(", "1", ")", ";", "}", "</s>" ]

[ "This", "routine", "initializes", "the", "dispatch", "scheduling", "information", ".", "It", "initiates", "building", "dispatch", "scheduler", "tables", "and", "constructs", "the", "first", "dispatch", "window", "." ]

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

[]

[ "<s>", "void", "thumb_reload_out_hi", "(", "rtx", "*", "operands", ")", "{", "emit_insn", "(", "gen_thumb_movhi_clobber", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "}", "</s>" ]

[ "Handle", "storing", "a", "half-word", "to", "memory", "during", "reload", "." ]

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

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isLinux", "(", ")", ")", "return", "false", ";", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "const", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getTargetData", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

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

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Sparc32", ")", ";", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "RetAddrOffset", "=", "8", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "SparcMachineFunctionInfo", "*", "SFI", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "SFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "SP", "::", "I0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "SP", "::", "I0", ")", ";", "RetAddrOffset", "=", "12", ";", "}", "SDValue", "RetAddrOffsetNode", "=", "DAG", ".", "getConstant", "(", "RetAddrOffset", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetAddrOffsetNode", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetAddrOffsetNode", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "ISD::OutputArg", "16", "Sparc", "0", "0", "\"Can only return in registers!\"", "1", "8", "Sparc", "Sparc", "\"sret virtual register not created in the entry block\"", "SP::I0", "1", "SP::I0", "12", "MVT::i32", "SPISD::RET_FLAG", "MVT::Other", "SPISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "rtx", "rs6000_libcall_value", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "mode", "==", "DImode", ")", "return", "rs6000_parallel_return", "(", "mode", ",", "2", ",", "SImode", ",", "GP_ARG_RETURN", ",", "1", ")", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "regno", "=", "(", "mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "else", "if", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "(", "(", "TARGET_SINGLE_FLOAT", "&&", "mode", "==", "SFmode", ")", "||", "TARGET_DOUBLE_FLOAT", ")", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TARGET_HARD_FLOAT", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DCmode", "||", "FLOAT128_IBM_P", "(", "mode", ")", "||", "mode", "==", "TCmode", ")", ")", "return", "spe_build_register_parallel", "(", "mode", ",", "GP_ARG_RETURN", ")", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "library", "function", "assuming", "the", "value", "has", "mode", "MODE", "." ]

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

[]

[ "<s>", "static", "inline", "bool", "mips_constant_elt_p", "(", "rtx", "x", ")", "{", "return", "CONST_INT_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "mips_expand_vec_init", ",", "match", "constant", "vector", "elements", "." ]

[ "mips" ]

[]

[ "<s>", "void", "s390_expand_vec_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "bool", "all_same", "=", "true", ",", "all_regs", "=", "true", ",", "all_const_int", "=", "true", ";", "rtx", "x", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "x", ")", ")", "all_const_int", "=", "false", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "all_regs", "=", "false", ";", "}", "if", "(", "all_same", "&&", "all_const_int", "&&", "(", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", "==", "const0_rtx", "||", "s390_contiguous_bitmask_vector_p", "(", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "NULL", ",", "NULL", ")", "||", "s390_bytemask_vector_p", "(", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "NULL", ")", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ")", ";", "return", ";", "}", "if", "(", "all_same", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ")", ";", "return", ";", "}", "if", "(", "all_regs", "&&", "REG_P", "(", "target", ")", "&&", "n_elts", "==", "2", "&&", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "8", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_VEC_CONCAT", "(", "mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_VXE", "&&", "(", "mode", "==", "V4SImode", "||", "mode", "==", "V4SFmode", ")", ")", "{", "bool", "found", "=", "true", ";", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ";", "if", "(", "memory_operand", "(", "x", ",", "inner_mode", ")", ")", "{", "for", "(", "i", "=", "1", ";", "i", "<", "n_elts", ";", "++", "i", ")", "found", "=", "found", "&&", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", "==", "const0_rtx", ";", "if", "(", "found", ")", "{", "machine_mode", "half_mode", "=", "(", "inner_mode", "==", "SFmode", "?", "V2SFmode", ":", "V2SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_VEC_CONCAT", "(", "mode", ",", "gen_rtx_VEC_CONCAT", "(", "half_mode", ",", "x", ",", "const0_rtx", ")", ",", "gen_rtx_VEC_CONCAT", "(", "half_mode", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ")", ")", ";", "return", ";", "}", "}", "}", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "CONST0_RTX", "(", "mode", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "elem", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "general_operand", "(", "elem", ",", "GET_MODE", "(", "elem", ")", ")", ")", "elem", "=", "force_reg", "(", "inner_mode", ",", "elem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "elem", ",", "GEN_INT", "(", "i", ")", ",", "target", ")", ",", "UNSPEC_VEC_SET", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "RTX", "necessary", "to", "initialize", "the", "vector", "TARGET", "with", "values", "in", "VALS", "." ]

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

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i8", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">=", "512", ")", "{", "EVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "const", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "NumElts", ")", ";", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "NumElts", ")", ";", "}", "if", "(", "VT", ".", "isSimple", "(", ")", ")", "{", "MVT", "VVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "const", "unsigned", "NumElts", "=", "VVT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "EltVT", "=", "VVT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "NumElts", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", "&&", "getTypeAction", "(", "Context", ",", "VT", ")", "==", "TypePromoteInteger", ")", "{", "EVT", "LegalVT", "=", "getTypeToTransformTo", "(", "Context", ",", "VT", ")", ";", "EltVT", "=", "LegalVT", ".", "getVectorElementType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "}", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", "&&", "EltVT", ".", "getSizeInBits", "(", ")", ">=", "32", ")", "switch", "(", "NumElts", ")", "{", "case", "2", ":", "return", "MVT", "::", "v2i1", ";", "case", "4", ":", "return", "MVT", "::", "v4i1", ";", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "X86", "X86", "MVT::i8", "512", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i1", "MVT::getVectorVT", "MVT::i1", "32", "2", "MVT::v2i1", "4", "MVT::v4i1", "8", "MVT::v8i1" ]

[]

[ "<s>", "static", "void", "cris_setup_incoming_varargs", "(", "cumulative_args_t", "ca_v", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_arg_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "if", "(", "ca", "->", "regs", "<", "CRIS_MAX_ARGS_IN_REGS", ")", "{", "int", "stdarg_regs", "=", "CRIS_MAX_ARGS_IN_REGS", "-", "ca", "->", "regs", ";", "cfun", "->", "machine", "->", "stdarg_regs", "=", "stdarg_regs", ";", "*", "pretend_arg_size", "=", "stdarg_regs", "*", "4", ";", "}", "if", "(", "TARGET_PDEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\\n\"", ",", "ca", "->", "regs", ",", "*", "pretend_arg_size", ",", "second_time", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "cris", "4", "\"\\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\\n\"" ]

[]

[ "<s>", "static", "bool", "aarch64_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "(", "CONST_DOUBLE_P", "(", "x", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "return", "true", ";", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "==", "(", "VEC_ADVSIMD", "|", "VEC_STRUCT", ")", ")", "return", "false", ";", "if", "(", "vec_flags", "&", "VEC_ANY_SVE", ")", "return", "aarch64_simd_valid_immediate", "(", "x", ",", "NULL", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "poly_int64", "offset", ";", "if", "(", "poly_int_rtx_p", "(", "x", ",", "&", "offset", ")", ")", "return", "aarch64_offset_temporaries", "(", "false", ",", "offset", ")", "<=", "1", ";", "x", "=", "strip_offset", "(", "x", ",", "&", "offset", ")", ";", "if", "(", "!", "offset", ".", "is_constant", "(", ")", "&&", "aarch64_offset_temporaries", "(", "true", ",", "offset", ")", ">", "0", ")", "return", "false", ";", "if", "(", "maybe_ne", "(", "offset", ",", "0", ")", "&&", "SYMBOL_REF_P", "(", "x", ")", "&&", "SYMBOL_REF_ANCHOR_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "&&", "!", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "hook", ".", "Return", "true", "for", "constants", "that", "should", "be", "rematerialized", "rather", "than", "spilled", "." ]

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

[]

[ "<s>", "static", "bool", "sh_assemble_integer", "(", "rtx", "value", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "TARGET_FDPIC", "&&", "size", "==", "UNITS_PER_WORD", "&&", "GET_CODE", "(", "value", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "value", ")", ")", "{", "fputs", "(", "\"\\t.long\\t\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "value", ")", ";", "fputs", "(", "\"@FUNCDESC\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "value", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Implementation", "of", "TARGET_ASM_INTEGER", "for", "SH", ".", "Pointers", "to", "functions", "need", "to", "be", "output", "as", "pointers", "to", "function", "descriptors", "for", "FDPIC", "." ]

[ "sh", "\"\\t.long\\t\"", "\"@FUNCDESC\\n\"" ]

[]

[ "<s>", "static", "int", "fr30_num_arg_regs", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "int", "size", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "if", "(", "type", "&&", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "word", "sized", "registers", "needed", "to", "hold", "a", "function", "argument", "of", "mode", "INT_MODE", "and", "tree", "type", "TYPE", "." ]

[ "fr30", "0", "1" ]

[]

[ "<s>", "static", "bool", "global_regs_p", "(", "unsigned", "first", ",", "unsigned", "last", ")", "{", "while", "(", "first", "<", "last", ")", "if", "(", "global_regs", "[", "first", "++", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Look", "for", "user-defined", "global", "regs", "in", "the", "range", "FIRST", "to", "LAST-1", ".", "We", "should", "not", "restore", "these", ",", "and", "so", "can", "not", "use", "lmw", "or", "out-of-line", "restore", "functions", "if", "there", "are", "any", ".", "We", "also", "ca", "n't", "save", "them", "(", "well", ",", "emit", "frame", "notes", "for", "them", ")", ",", "because", "frame", "unwinding", "during", "exception", "handling", "will", "restore", "saved", "registers", "." ]

[ "rs6000" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "LEGInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "MBB", ".", "empty", "(", ")", ")", "return", "0", ";", "unsigned", "NumRemoved", "=", "0", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "do", "{", "--", "I", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "LEG", "::", "B", ")", "||", "(", "Opc", "==", "LEG", "::", "Bcc", ")", ")", "{", "auto", "ToDelete", "=", "I", ";", "++", "I", ";", "MBB", ".", "erase", "(", "ToDelete", ")", ";", "NumRemoved", "++", ";", "}", "}", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", ";", "return", "NumRemoved", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "LEG", "LEG", "0", "0", "LEG::B", "LEG::Bcc" ]

[]

[ "<s>", "bool", "BPFAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "(", "Count", "%", "8", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "8", ")", "OW", "->", "write64", "(", "0x15000000", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "8", "0", "0", "8", "0x15000000" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "get_probe_interval", "(", "void", ")", "{", "if", "(", "flag_stack_clash_protection", ")", "return", "(", "HOST_WIDE_INT_1U", "<<", "PARAM_VALUE", "(", "PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL", ")", ")", ";", "else", "return", "(", "HOST_WIDE_INT_1U", "<<", "STACK_CHECK_PROBE_INTERVAL_EXP", ")", ";", "}", "</s>" ]

[ "Return", "the", "probing", "interval", "for", "-fstack-clash-protection", "." ]

[ "i386" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MBlaze", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "unsigned", "Ret", "=", "(", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ")", "?", "MBlazeISD", "::", "IRet", ":", "MBlazeISD", "::", "Ret", ";", "unsigned", "Reg", "=", "(", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ")", "?", "MBlaze", "::", "R14", ":", "MBlaze", "::", "R15", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "MVT", "::", "i32", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::OutputArg", "16", "MBlaze", "4", "1", "MBlazeISD::IRet", "MBlazeISD::Ret", "MBlaze::R14", "MBlaze::R15", "MVT::i32", "0", "\"Can only return in registers!\"", "1", "0", "MVT::Other", "0" ]

[]

[ "<s>", "static", "bool", "ia64_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "lookup_attribute", "(", "\"syscall_linkage\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", ")", "return", "false", ";", "return", "(", "decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "||", "TARGET_CONST_GP", ";", "}", "</s>" ]

[ "True", "if", "it", "is", "OK", "to", "do", "sibling", "call", "optimization", "for", "the", "specified", "call", "expression", "EXP", ".", "DECL", "will", "be", "the", "called", "function", ",", "or", "NULL", "if", "this", "is", "an", "indirect", "call", "." ]

[ "ia64", "\"syscall_linkage\"" ]

[]

[ "<s>", "static", "int", "first_altivec_reg_to_save", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_ALTIVEC_ABI", ")", "return", "LAST_ALTIVEC_REGNO", "+", "1", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "regs_ever_live", "[", "i", "]", ")", "break", ";", "return", "i", ";", "}", "</s>" ]

[ "Similar", ",", "for", "AltiVec", "regs", "." ]

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

[]

[ "<s>", "void", "Z80RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "void", "SystemZRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unxpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "Offset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "getMemoryInstr", "(", "MI", ".", "getOpcode", "(", ")", ",", "Offset", ")", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "\"Unxpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "SystemZ::R11D", "SystemZ::R15D", "1", "1" ]

[]

[ "<s>", "X86Subtarget", "&", "X86Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "mips_sim_wait_insn", "(", "struct", "mips_sim", "*", "state", ",", "rtx_insn", "*", "insn", ")", "{", "mips_sim_wait_regs", "(", "state", ",", "insn", ")", ";", "mips_sim_wait_units", "(", "state", ",", "insn", ")", ";", "}", "</s>" ]

[ "Advance", "simulation", "state", "STATE", "until", "INSN", "is", "ready", "to", "issue", "." ]

[ "mips" ]

[]

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

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

[ "RV16K", "RV16K", "RV16KOperand::createToken", "\"unexpected token\"" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Mips", "::", "CPURegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "if", "(", "RC", "==", "Mips", "::", "FGR32RegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SWC1", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "if", "(", "RC", "==", "Mips", "::", "AFGR64RegisterClass", ")", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isMips1", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SDC1", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "else", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "unsigned", "*", "SubSet", "=", "TRI", "->", "getSubRegisters", "(", "SrcReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SWC1", ")", ")", ".", "addReg", "(", "SubSet", "[", "0", "]", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "SWC1", ")", ")", ".", "addReg", "(", "SubSet", "[", "1", "]", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "4", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "}", "else", "llvm_unreachable", "(", "\"Register class not handled!\"", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::CPURegsRegisterClass", "Mips::SW", "0", "Mips::FGR32RegisterClass", "Mips::SWC1", "0", "Mips::AFGR64RegisterClass", "Mips", "Mips", "Mips::SDC1", "0", "Mips::SWC1", "0", "0", "Mips::SWC1", "1", "4", "\"Register class not handled!\"" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "Res", "=", "LowerREM", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "Res", "=", "LowerDivRem", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "assert", "(", "Res", ".", "getNumOperands", "(", ")", "==", "2", "&&", "\"DivRem needs two values\"", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SDIV", ":", "assert", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "\"can only expand DIV on Windows\"", ")", ";", "return", "ExpandDIV_Windows", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ",", "Results", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceCMP_SWAP_64Results", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SREM", "ISD::UREM", "ISD::SDIVREM", "ISD::UDIVREM", "0", "2", "\"DivRem needs two values\"", "0", "1", "ISD::READCYCLECOUNTER", "ISD::UDIV", "ISD::SDIV", "\"can only expand DIV on Windows\"", "0", "ISD::SDIV", "ISD::ATOMIC_CMP_SWAP" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_i", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "uint64_t", "Imm", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "a", "single", "immediate", "operand", ",", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

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

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "AtStart", "=", "MI", "==", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "BeforeI", "=", "MI", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitEpilogue\"", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "if", "(", "AtStart", ")", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "MI", "=", "BeforeI", ";", "++", "MI", ";", "}", "}", "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", "(", ")", "." ]

[ "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitEpilogue\"", "\"loadRegFromStackSlot didn't insert any code!\"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_ops_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "machine_mode", "cmp_mode", ";", "bool", "maskcmp", "=", "false", ";", "rtx", "x", ";", "if", "(", "GET_MODE_SIZE", "(", "cmp_ops_mode", ")", "==", "64", ")", "{", "cmp_mode", "=", "mode_for_size", "(", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ",", "MODE_INT", ",", "0", ")", ";", "gcc_assert", "(", "cmp_mode", "!=", "BLKmode", ")", ";", "maskcmp", "=", "true", ";", "}", "else", "cmp_mode", "=", "cmp_ops_mode", ";", "cmp_op0", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op0", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "cmp_op1", ",", "cmp_ops_mode", ")", ")", "cmp_op1", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op1", ")", ";", "if", "(", "optimize", "||", "(", "op_true", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_true", ")", ")", "||", "(", "op_false", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_false", ")", ")", ")", "dest", "=", "gen_reg_rtx", "(", "maskcmp", "?", "cmp_mode", ":", "mode", ")", ";", "if", "(", "maskcmp", "&&", "(", "code", "==", "GT", "||", "code", "==", "EQ", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "cmp_ops_mode", ")", "{", "case", "V64QImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv64qi3", ":", "gen_avx512bw_eqv64qi3_1", ";", "break", ";", "case", "V32HImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv32hi3", ":", "gen_avx512bw_eqv32hi3_1", ";", "break", ";", "case", "V16SImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv16si3", ":", "gen_avx512f_eqv16si3_1", ";", "break", ";", "case", "V8DImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv8di3", ":", "gen_avx512f_eqv8di3_1", ";", "break", ";", "default", ":", "gen", "=", "NULL", ";", "}", "if", "(", "gen", ")", "{", "emit_insn", "(", "gen", "(", "dest", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "return", "dest", ";", "}", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", "&&", "!", "maskcmp", ")", "{", "x", "=", "force_reg", "(", "cmp_ops_mode", ",", "x", ")", ";", "convert_move", "(", "dest", ",", "x", ",", "false", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Expand", "an", "sse", "vector", "comparison", ".", "Return", "the", "register", "with", "the", "result", "." ]

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

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSTRspi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegClass", "ARM", "ARM::tSTRspi", "0", "ARMCC::AL" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "const", "Function", "&", "Fn", "=", "*", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "StringRef", "FuncName", "(", "\"<unknown>\"", ")", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "G", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getSymbol", "(", ")", ";", "else", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "DiagnosticInfoUnsupported", "NoCalls", "(", "Fn", ",", "\"unsupported call to function \"", "+", "FuncName", ",", "CLI", ".", "DL", ".", "getDebugLoc", "(", ")", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "NoCalls", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"<unknown>\"", "\"unsupported call to function \"" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SystemZ", "::", "GR128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SystemZ", "::", "subreg_h64", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SystemZ", "::", "subreg_h64", ")", ",", "KillSrc", ")", ";", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SystemZ", "::", "subreg_l64", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SystemZ", "::", "subreg_l64", ")", ",", "KillSrc", ")", ";", "return", ";", "}", "if", "(", "SystemZ", "::", "GRX32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "emitGRX32Move", "(", "MBB", ",", "MBBI", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "SystemZ", "::", "LR", ",", "32", ",", "KillSrc", ")", ";", "return", ";", "}", "unsigned", "Opcode", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LGR", ";", "else", "if", "(", "SystemZ", "::", "FP32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LER", ";", "else", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LDR", ";", "else", "if", "(", "SystemZ", "::", "FP128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LXR", ";", "else", "if", "(", "SystemZ", "::", "VR32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR32", ";", "else", "if", "(", "SystemZ", "::", "VR64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR64", ";", "else", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::GR128BitRegClass", "SystemZ::subreg_h64", "SystemZ::subreg_h64", "SystemZ::subreg_l64", "SystemZ::subreg_l64", "SystemZ::GRX32BitRegClass", "SystemZ::LR", "32", "SystemZ::GR64BitRegClass", "SystemZ::LGR", "SystemZ::FP32BitRegClass", "SystemZ::LER", "SystemZ::FP64BitRegClass", "SystemZ::LDR", "SystemZ::FP128BitRegClass", "SystemZ::LXR", "SystemZ::VR32BitRegClass", "SystemZ::VLR32", "SystemZ::VR64BitRegClass", "SystemZ::VLR64", "SystemZ::VR128BitRegClass", "SystemZ::VLR", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "uint64_t", "getNullPointerValue", "(", "unsigned", "AddrSpace", ")", "const", "{", "if", "(", "AddrSpace", "==", "AS", ".", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AS", ".", "REGION_ADDRESS", ")", "return", "-", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Get", "the", "integer", "value", "of", "a", "null", "pointer", "in", "the", "given", "address", "space", "." ]

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

[]

[ "<s>", "bool", "AArch64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64DeadRegisterDefinitions *****\\n\"", ")", ";", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "if", "(", "processMachineBasicBlock", "(", "MBB", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64DeadRegisterDefinitions *****\\n\"" ]

[]

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

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

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

[]

[ "<s>", "void", "MipsSEInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MipsABIInfo", "ABI", "=", "Subtarget", ".", "getABI", "(", ")", ";", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "ADDu", "=", "ABI", ".", "GetPtrAdduOp", "(", ")", ";", "unsigned", "ADDiu", "=", "ABI", ".", "GetPtrAddiuOp", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "else", "{", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "nullptr", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "Mips", "0", "16" ]

[]

[ "<s>", "static", "int", "need_to_save", "(", "int", "regno", ")", "{", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "0", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "1", ";", "if", "(", "regno", "==", "FP_REGNO", ")", "return", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "&&", "(", "!", "cfun", "->", "machine", "->", "is_leaf", "||", "(", "regno", "==", "A0_REGNO", "&&", "m32c_function_needs_enter", "(", ")", ")", ")", ")", "return", "1", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "given", "register", "needs", "to", "be", "saved", "by", "the", "current", "function", "." ]

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

[]

[ "<s>", "uint64_t", "MipsFrameLowering", "::", "estimateStackSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int64_t", "Offset", "=", "0", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "Offset", "=", "std", "::", "max", "(", "Offset", ",", "-", "MFI", "->", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "const", "MCPhysReg", "*", "R", "=", "TRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "{", "unsigned", "Size", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "*", "R", ")", "->", "getSize", "(", ")", ";", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "Size", ",", "Size", ")", ";", "}", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "assert", "(", "!", "MFI", "->", "getObjectIndexEnd", "(", ")", "||", "MaxAlign", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "MFI", "->", "getObjectSize", "(", "I", ")", ",", "MaxAlign", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "MFI", "->", "getMaxCallFrameSize", "(", ")", ",", "std", "::", "max", "(", "MaxAlign", ",", "getStackAlignment", "(", ")", ")", ")", ";", "return", "RoundUpToAlignment", "(", "Offset", ",", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]

[ "Estimate", "and", "return", "the", "size", "of", "the", "stack", "frame", "." ]

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

[]

[ "<s>", "static", "int", "stackSlotSize", "(", ")", "{", "return", "4", ";", "}", "</s>" ]

[ "Stack", "slot", "size", "(", "4", "bytes", ")" ]

[ "TriCore", "4" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "TM", ".", "getDataLayout", "(", ")", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "EmitFunctionStubs", "(", "Stubs", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "const", "std", "::", "vector", "<", "const", "Function", "*", ">", "&", "Personalities", "=", "MMI", "->", "getPersonalities", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "const", "Function", "*", ">", "::", "const_iterator", "I", "=", "Personalities", ".", "begin", "(", ")", ",", "E", "=", "Personalities", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "*", "I", ")", "{", "MCSymbol", "*", "NLPSym", "=", "getSymbolWithGlobalValueBase", "(", "*", "I", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "*", "I", ")", ",", "true", ")", ";", "}", "}", "}", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", "->", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "else", "OutStreamer", "->", "EmitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetHiddenGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", "->", "EmitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "PPC", "8", "4", "PPC", "3", "2", "0", "PPC", "8", "4" ]

[]

[ "<s>", "static", "rtx", "restore_fpr", "(", "rtx", "base", ",", "int", "offset", ",", "int", "regnum", ")", "{", "rtx", "addr", ";", "addr", "=", "gen_rtx_MEM", "(", "DFmode", ",", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "return", "emit_move_insn", "(", "gen_rtx_REG", "(", "DFmode", ",", "regnum", ")", ",", "addr", ")", ";", "}", "</s>" ]

[ "Emit", "insn", "to", "restore", "fpr", "REGNUM", "from", "offset", "OFFSET", "relative", "to", "register", "BASE", ".", "Return", "generated", "insn", "." ]

[ "s390" ]

[]

[ "<s>", "static", "enum", "ivms_arg_type", "ia64_arg_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "FS", ";", "case", "E_DFmode", ":", "return", "FT", ";", "default", ":", "return", "I64", ";", "}", "}", "</s>" ]

[ "Return", "ivms_arg_type", "based", "on", "machine_mode", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "emitSparcRegisterIgnore", "(", "unsigned", "reg", ")", "override", "{", "}", "</s>" ]

[ "Emit", "``", ".register", "<", "reg", ">", ",", "#", "ignore", "''", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "RangeTree", "::", "Node", "*", "RangeTree", "::", "add", "(", "Node", "*", "N", ",", "const", "OffsetRange", "&", "R", ")", "{", "if", "(", "N", "==", "nullptr", ")", "return", "new", "Node", "(", "R", ")", ";", "if", "(", "N", "->", "Range", "==", "R", ")", "{", "N", "->", "Count", "++", ";", "return", "N", ";", "}", "if", "(", "R", "<", "N", "->", "Range", ")", "N", "->", "Left", "=", "add", "(", "N", "->", "Left", ",", "R", ")", ";", "else", "N", "->", "Right", "=", "add", "(", "N", "->", "Right", ",", "R", ")", ";", "return", "rebalance", "(", "update", "(", "N", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "string", "to", "the", "builder", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "SavedRegs", ".", "set", "(", "RISCV", "::", "X1", ")", ";", "SavedRegs", ".", "set", "(", "RISCV", "::", "X8", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::X1", "RISCV::X8" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "dump_csky_minipool", "(", "rtx_insn", "*", "scan", ")", "{", "Mnode", "*", "mp", ";", "Mnode", "*", "nmp", ";", "HOST_WIDE_INT", "pool_length", "=", "0", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; Emitting minipool after insn %u;\\ address %ld; align %d (bytes)\\n\"", ",", "INSN_UID", "(", "scan", ")", ",", "(", "unsigned", "long", ")", "minipool_barrier", "->", "address", ",", "4", ")", ";", "scan", "=", "emit_insn_after", "(", "gen_align_4", "(", ")", ",", "scan", ")", ";", "scan", "=", "emit_insn_after", "(", "minipool_vector_label", ",", "scan", ")", ";", "for", "(", "mp", "=", "minipool_vector_head", ";", "mp", "!=", "NULL", ";", "mp", "=", "nmp", ")", "{", "if", "(", "mp", "->", "refcount", ">", "0", ")", "{", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Offset %u, min %ld, max %ld \"", ",", "(", "unsigned", ")", "mp", "->", "offset", ",", "(", "unsigned", "long", ")", "mp", "->", "min_address", ",", "(", "unsigned", "long", ")", "mp", "->", "max_address", ")", ";", "print_csky_value", "(", "dump_file", ",", "mp", "->", "value", ")", ";", "fputc", "(", "'\\n'", ",", "dump_file", ")", ";", "}", "switch", "(", "mp", "->", "fix_size", ")", "{", "case", "4", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_4", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "pool_length", "+=", "4", ";", "break", ";", "case", "8", ":", "scan", "=", "emit_insn_after", "(", "gen_consttable_8", "(", "mp", "->", "value", ")", ",", "scan", ")", ";", "pool_length", "+=", "8", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "nmp", "=", "mp", "->", "next", ";", "free", "(", "mp", ")", ";", "}", "minipool_vector_head", "=", "minipool_vector_tail", "=", "NULL", ";", "scan", "=", "emit_barrier_after", "(", "scan", ")", ";", "return", "pool_length", ";", "}", "</s>" ]

[ "Output", "the", "literal", "table", "." ]

[ "csky", "0", "\";; Emitting minipool after insn %u;\\ address %ld; align %d (bytes)\\n\"", "4", "0", "\";; Offset %u, min %ld, max %ld \"", "4", "4", "8", "8" ]

[]

[ "<s>", "VSETVLIInfo", "intersect", "(", "const", "VSETVLIInfo", "&", "Other", ")", "const", "{", "if", "(", "!", "Other", ".", "isValid", "(", ")", ")", "return", "*", "this", ";", "if", "(", "!", "isValid", "(", ")", ")", "return", "Other", ";", "if", "(", "*", "this", "==", "Other", ")", "return", "*", "this", ";", "return", "VSETVLIInfo", "::", "getUnknown", "(", ")", ";", "}", "</s>" ]

[ "Intersect", "this", "set", "with", "a", "temporary", "other", "set", "in", "place", "." ]

[ "RISCV", "VSETVLIInfo::getUnknown" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "getOppositeBranchOpc", "(", "unsigned", "Opc", ")", "const", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Illegal opcode!\"", ")", ";", "case", "Mips", "::", "BEQ", ":", "return", "Mips", "::", "BNE", ";", "case", "Mips", "::", "BNE", ":", "return", "Mips", "::", "BEQ", ";", "case", "Mips", "::", "BGTZ", ":", "return", "Mips", "::", "BLEZ", ";", "case", "Mips", "::", "BGEZ", ":", "return", "Mips", "::", "BLTZ", ";", "case", "Mips", "::", "BLTZ", ":", "return", "Mips", "::", "BGEZ", ";", "case", "Mips", "::", "BLEZ", ":", "return", "Mips", "::", "BGTZ", ";", "case", "Mips", "::", "BEQ64", ":", "return", "Mips", "::", "BNE64", ";", "case", "Mips", "::", "BNE64", ":", "return", "Mips", "::", "BEQ64", ";", "case", "Mips", "::", "BGTZ64", ":", "return", "Mips", "::", "BLEZ64", ";", "case", "Mips", "::", "BGEZ64", ":", "return", "Mips", "::", "BLTZ64", ";", "case", "Mips", "::", "BLTZ64", ":", "return", "Mips", "::", "BGEZ64", ";", "case", "Mips", "::", "BLEZ64", ":", "return", "Mips", "::", "BGTZ64", ";", "case", "Mips", "::", "BC1T", ":", "return", "Mips", "::", "BC1F", ";", "case", "Mips", "::", "BC1F", ":", "return", "Mips", "::", "BC1T", ";", "case", "Mips", "::", "BEQZC_MM", ":", "return", "Mips", "::", "BNEZC_MM", ";", "case", "Mips", "::", "BNEZC_MM", ":", "return", "Mips", "::", "BEQZC_MM", ";", "case", "Mips", "::", "BEQZC", ":", "return", "Mips", "::", "BNEZC", ";", "case", "Mips", "::", "BNEZC", ":", "return", "Mips", "::", "BEQZC", ";", "case", "Mips", "::", "BEQC", ":", "return", "Mips", "::", "BNEC", ";", "case", "Mips", "::", "BNEC", ":", "return", "Mips", "::", "BEQC", ";", "case", "Mips", "::", "BGTZC", ":", "return", "Mips", "::", "BLEZC", ";", "case", "Mips", "::", "BGEZC", ":", "return", "Mips", "::", "BLTZC", ";", "case", "Mips", "::", "BLTZC", ":", "return", "Mips", "::", "BGEZC", ";", "case", "Mips", "::", "BLEZC", ":", "return", "Mips", "::", "BGTZC", ";", "}", "}", "</s>" ]

[ "getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "." ]

[ "Mips", "Mips", "\"Illegal opcode!\"", "Mips::BEQ", "Mips::BNE", "Mips::BNE", "Mips::BEQ", "Mips::BGTZ", "Mips::BLEZ", "Mips::BGEZ", "Mips::BLTZ", "Mips::BLTZ", "Mips::BGEZ", "Mips::BLEZ", "Mips::BGTZ", "Mips::BEQ64", "Mips::BNE64", "Mips::BNE64", "Mips::BEQ64", "Mips::BGTZ64", "Mips::BLEZ64", "Mips::BGEZ64", "Mips::BLTZ64", "Mips::BLTZ64", "Mips::BGEZ64", "Mips::BLEZ64", "Mips::BGTZ64", "Mips::BC1T", "Mips::BC1F", "Mips::BC1F", "Mips::BC1T", "Mips::BEQZC_MM", "Mips::BNEZC_MM", "Mips::BNEZC_MM", "Mips::BEQZC_MM", "Mips::BEQZC", "Mips::BNEZC", "Mips::BNEZC", "Mips::BEQZC", "Mips::BEQC", "Mips::BNEC", "Mips::BNEC", "Mips::BEQC", "Mips::BGTZC", "Mips::BLEZC", "Mips::BGEZC", "Mips::BLTZC", "Mips::BLTZC", "Mips::BGEZC", "Mips::BLEZC", "Mips::BGTZC" ]

[]

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

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

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

[]

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

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

[ "SNES" ]

[]

[ "<s>", "void", "ARMBankConflictHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "&", "MI", "=", "*", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", ".", "mayLoad", "(", ")", "||", "MI", ".", "mayStore", "(", ")", "||", "MI", ".", "getNumMemOperands", "(", ")", "!=", "1", ")", "return", ";", "auto", "MO", "=", "*", "MI", ".", "memoperands", "(", ")", ".", "begin", "(", ")", ";", "uint64_t", "Size1", "=", "MO", "->", "getSize", "(", ")", ";", "if", "(", "Size1", ">", "4", ")", "return", ";", "Accesses", ".", "push_back", "(", "&", "MI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCPhysReg", "*", "ARM64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_ARM64_AllRegs_SaveList", ";", "else", "return", "CSR_ARM64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"Invalid MachineFunction pointer.\"", "ARM64", "ARM64" ]

[]

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

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

[ "TLCS900" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "*", "DL", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", "->", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mang", "->", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "GetOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "PPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_NLP_HIDDEN_FLAG", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValueMMR6", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValueMMR6 expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "FixupExpression", "=", "MCBinaryExpr", "::", "createAdd", "(", "MO", ".", "getExpr", "(", ")", ",", "MCConstantExpr", "::", "create", "(", "-", "2", ",", "Ctx", ")", ",", "Ctx", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "FixupExpression", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_PC16", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "\"getBranchTargetOpValueMMR6 expects only expressions or immediates\"", "2", "0", "Mips::fixup_Mips_PC16", "0" ]

[]

[ "<s>", "void", "MipsELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "MCContext", "&", "Context", "=", "getContext", "(", ")", ";", "const", "MCRegisterInfo", "*", "MCRegInfo", "=", "Context", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "unsigned", "OpIndex", "=", "0", ";", "OpIndex", "<", "Inst", ".", "getNumOperands", "(", ")", ";", "++", "OpIndex", ")", "{", "const", "MCOperand", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpIndex", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "RegInfoRecord", "->", "SetPhysRegUsed", "(", "Reg", ",", "MCRegInfo", ")", ";", "}", "createPendingLabelRelocs", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "rs6000_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "from", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "?", "!", "TARGET_MINIMAL_TOC", "||", "TARGET_NO_TOC", "||", "constant_pool_empty_p", "(", ")", ":", "true", ")", ";", "}", "</s>" ]

[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "For", "the", "RS/6000", ",", "if", "frame", "pointer", "elimination", "is", "being", "done", ",", "we", "would", "like", "to", "convert", "ap", "into", "fp", ",", "not", "sp", ".", "We", "need", "r30", "if", "-mminimal-toc", "was", "specified", ",", "and", "there", "are", "constant", "pool", "references", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "llvm", "::", "Type", "*", "getVectorElementType", "(", "llvm", "::", "Type", "*", "Ty", ")", "{", "return", "llvm", "::", "cast", "<", "llvm", "::", "FixedVectorType", ">", "(", "Ty", ")", "->", "getElementType", "(", ")", ";", "}", "</s>" ]

[ "Given", "a", "vector", "type", ",", "return", "the", "type", "of", "each", "element", "." ]

[ "VE" ]

[]

[ "<s>", "int", "m32r_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "(", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "PIC", "." ]

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

[]

[ "<s>", "static", "void", "frv_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "frv_stack_info", "(", ")", "->", "total_size", "==", "0", "&&", "frv_function_contains_far_jump", "(", ")", ")", "{", "rtx", "insn", ";", "gcc_assert", "(", "!", "regs_ever_live", "[", "GPR_FIRST", "+", "3", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\tmovsg lr,gr3\\n\"", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "NULL", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", "&&", "XVECLEN", "(", "pattern", ",", "0", ")", ">=", "2", "&&", "GET_CODE", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", "==", "RETURN", "&&", "GET_CODE", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", ")", "==", "USE", ")", "{", "rtx", "address", "=", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "address", ")", "==", "REG", "&&", "REGNO", "(", "address", ")", "==", "LR_REGNO", ")", "REGNO", "(", "address", ")", "=", "GPR_FIRST", "+", "3", ";", "}", "}", "}", "frv_pack_insns", "(", ")", ";", "memset", "(", "frv_nops", ",", "0", ",", "sizeof", "(", "frv_nops", ")", ")", ";", "}", "</s>" ]

[ "For", "the", "FRV", ",", "this", "function", "makes", "sure", "that", "a", "function", "with", "far", "jumps", "will", "return", "correctly", ".", "It", "also", "does", "the", "VLIW", "packing", "." ]

[ "frv", "0", "3", "\"\\tmovsg lr,gr3\\n\"", "0", "2", "0", "0", "0", "1", "0", "1", "0", "3", "0" ]

[]

[ "<s>", "void", "mt_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "int", "incoming", ")", "{", "*", "cum", "=", "0", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nmt_init_cumulative_args:\"", ")", ";", "if", "(", "incoming", ")", "fputs", "(", "\" incoming\"", ",", "stderr", ")", ";", "if", "(", "fntype", ")", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\" return = %s,\"", ",", "tree_code_name", "[", "(", "int", ")", "TREE_CODE", "(", "ret_type", ")", "]", ")", ";", "}", "if", "(", "libname", "&&", "GET_CODE", "(", "libname", ")", "==", "SYMBOL_REF", ")", "fprintf", "(", "stderr", ",", "\" libname = %s\"", ",", "XSTR", "(", "libname", ",", "0", ")", ")", ";", "if", "(", "cfun", "->", "returns_struct", ")", "fprintf", "(", "stderr", ",", "\" return-struct\"", ")", ";", "putc", "(", "'\\n'", ",", "stderr", ")", ";", "}", "}", "</s>" ]

[ "Implement", "INIT_CUMULATIVE_ARGS", "." ]

[ "mt", "0", "\"\\nmt_init_cumulative_args:\"", "\" incoming\"", "\" return = %s,\"", "\" libname = %s\"", "0", "\" return-struct\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "PPCTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'b'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'d'", ":", "if", "(", "type", "->", "isDoubleTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'v'", ":", "if", "(", "type", "->", "isVectorTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'y'", ":", "weight", "=", "CW_Register", ";", "break", ";", "case", "'Z'", ":", "weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "(", "(", "ARMBaseTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "const", "ARMBaseInstrInfo", "*", ")", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "MF", ".", "getTarget", "(", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "IsThumb", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "0", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]