bool CompilerInstance::InitializeSourceManager(llvm::StringRef InputFile, Diagnostic &Diags, FileManager &FileMgr, SourceManager &SourceMgr, const FrontendOptions &Opts) { // Figure out where to get and map in the main file. if (Opts.EmptyInputOnly) { const char *EmptyStr = ""; llvm::MemoryBuffer *SB = llvm::MemoryBuffer::getMemBuffer(EmptyStr, EmptyStr, "<empty input>"); SourceMgr.createMainFileIDForMemBuffer(SB); } else if (InputFile != "-") { const FileEntry *File = FileMgr.getFile(InputFile); if (File) SourceMgr.createMainFileID(File, SourceLocation()); if (SourceMgr.getMainFileID().isInvalid()) { Diags.Report(diag::err_fe_error_reading) << InputFile; return false; } } else { llvm::MemoryBuffer *SB = llvm::MemoryBuffer::getSTDIN(); SourceMgr.createMainFileIDForMemBuffer(SB); if (SourceMgr.getMainFileID().isInvalid()) { Diags.Report(diag::err_fe_error_reading_stdin); return false; } } return true; }
void yasm::DirIntNum(NameValue& nv, Diagnostic& diags, Object* obj, IntNum* out, bool* out_set) { if (!nv.isExpr()) { diags.Report(nv.getNameSource(), diag::err_value_integer) << nv.getValueRange(); return; } std::auto_ptr<Expr> e(nv.ReleaseExpr(*obj)); e->Simplify(diags); if (!e->isIntNum()) { diags.Report(nv.getNameSource(), diag::err_value_integer) << nv.getValueRange(); return; } *out = e->getIntNum(); *out_set = true; }
void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, const char **ArgBegin, const char **ArgEnd, Diagnostic &Diags) { // Parse the arguments. llvm::OwningPtr<OptTable> Opts(createCC1OptTable()); unsigned MissingArgIndex, MissingArgCount; llvm::OwningPtr<InputArgList> Args( Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount)); // Check for missing argument error. if (MissingArgCount) Diags.Report(diag::err_drv_missing_argument) << Args->getArgString(MissingArgIndex) << MissingArgCount; // Issue errors on unknown arguments. for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN), ie = Args->filtered_end(); it != ie; ++it) Diags.Report(diag::err_drv_unknown_argument) << it->getAsString(*Args); ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags); ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, Diags); ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args); ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags); FrontendOptions::InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags); ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args); if (DashX != FrontendOptions::IK_AST) ParseLangArgs(Res.getLangOpts(), *Args, DashX, Diags); ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, Diags); ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args); ParseTargetArgs(Res.getTargetOpts(), *Args); }
static void CheckSymbol(const Symbol& sym, Diagnostic& diags) { int vis = sym.getVisibility(); // Don't check internally-generated symbols. Only internally generated // symbols have symrec data, so simply check for its presence. if (sym.getAssocData<BinSymbol>()) return; if (vis & Symbol::EXTERN) { diags.Report(sym.getDeclSource(), diag::warn_bin_unsupported_decl) << "EXTERN"; } else if (vis & Symbol::GLOBAL) { diags.Report(sym.getDeclSource(), diag::warn_bin_unsupported_decl) << "GLOBAL"; } else if (vis & Symbol::COMMON) { diags.Report(sym.getDeclSource(), diag::warn_bin_unsupported_decl) << "COMMON"; } }
bool Operand::Finalize(Diagnostic& diags) { switch (m_type) { case MEMORY: if (!m_ea) break; if (Expr* abs = m_ea->m_disp.getAbs()) { if (!ExpandEqu(*abs)) { diags.Report(m_source, diag::err_equ_circular_reference_mem); return false; } // Don't get over-ambitious here; some archs' memory expr // parser are sensitive to the presence of *1, etc, so don't // simplify reg*1 identities. abs->Simplify(diags, false); } break; case IMM: if (!ExpandEqu(*m_val)) { diags.Report(m_source, diag::err_equ_circular_reference_imm); return false; } m_val->Simplify(diags); break; default: break; } return true; }
bool CompilerInstance::InitializeSourceManager(llvm::StringRef InputFile, Diagnostic &Diags, FileManager &FileMgr, SourceManager &SourceMgr, const FrontendOptions &Opts) { // Figure out where to get and map in the main file, unless it's already // been created (e.g., by a precompiled preamble). if (!SourceMgr.getMainFileID().isInvalid()) { // Do nothing: the main file has already been set. } else if (InputFile != "-") { const FileEntry *File = FileMgr.getFile(InputFile); if (!File) { Diags.Report(diag::err_fe_error_reading) << InputFile; return false; } SourceMgr.createMainFileID(File); } else { llvm::OwningPtr<llvm::MemoryBuffer> SB; if (llvm::MemoryBuffer::getSTDIN(SB)) { // FIXME: Give ec.message() in this diag. Diags.Report(diag::err_fe_error_reading_stdin); return false; } const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), SB->getBufferSize(), 0); SourceMgr.createMainFileID(File); SourceMgr.overrideFileContents(File, SB.take()); } assert(!SourceMgr.getMainFileID().isInvalid() && "Couldn't establish MainFileID!"); return true; }
bool Bytecode::Finalize(Diagnostic& diags) { for (std::vector<Fixup>::iterator i=m_fixed_fixups.begin(), end=m_fixed_fixups.end(); i != end; ++i) { if (!i->Finalize(diags, i->isJumpTarget() ? diag::err_too_complex_jump : diag::err_too_complex_expression)) return false; if (i->isJumpTarget() && i->isComplexRelative()) { diags.Report(i->getSource().getBegin(), diag::err_invalid_jump_target); return false; } // Do curpos subtraction for IP-relative flagged values. if (i->isIPRelative()) { Location sub_loc = {this, i->getOffset()}; if (!i->SubRelative(m_container->getObject(), sub_loc)) diags.Report(i->getSource().getBegin(), diag::err_too_complex_expression); } } if (m_contents.get() != 0) return m_contents->Finalize(*this, diags); return true; }
// Initialize the remapping of files to alternative contents, e.g., // those specified through other files. static void InitializeFileRemapping(Diagnostic &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts) { // Remap files in the source manager (with buffers). for (PreprocessorOptions::const_remapped_file_buffer_iterator Remap = InitOpts.remapped_file_buffer_begin(), RemapEnd = InitOpts.remapped_file_buffer_end(); Remap != RemapEnd; ++Remap) { // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, Remap->second->getBufferSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << Remap->first; if (!InitOpts.RetainRemappedFileBuffers) delete Remap->second; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, Remap->second, InitOpts.RetainRemappedFileBuffers); } // Remap files in the source manager (with other files). for (PreprocessorOptions::const_remapped_file_iterator Remap = InitOpts.remapped_file_begin(), RemapEnd = InitOpts.remapped_file_end(); Remap != RemapEnd; ++Remap) { // Find the file that we're mapping to. const FileEntry *ToFile = FileMgr.getFile(Remap->second); if (!ToFile) { Diags.Report(diag::err_fe_remap_missing_to_file) << Remap->first << Remap->second; continue; } // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, ToFile->getSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << Remap->first; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, ToFile); } SourceMgr.setOverridenFilesKeepOriginalName( InitOpts.RemappedFilesKeepOriginalName); }
void BinObject::Output(llvm::raw_fd_ostream& os, bool all_syms, DebugFormat& dbgfmt, Diagnostic& diags) { // Set ORG to 0 unless otherwise specified IntNum origin(0); if (m_org.get() != 0) { m_org->Simplify(diags); if (!m_org->isIntNum()) { diags.Report(m_org_source, diag::err_org_too_complex); return; } IntNum orgi = m_org->getIntNum(); if (orgi.getSign() < 0) { diags.Report(m_org_source, diag::err_org_negative); return; } origin = orgi; } // Check symbol table for (Object::const_symbol_iterator i=m_object.symbols_begin(), end=m_object.symbols_end(); i != end; ++i) CheckSymbol(*i, diags); BinLink link(m_object, diags); if (!link.DoLink(origin)) return; // Output map file OutputMap(origin, link.getLMAGroups(), diags); // Ensure we don't have overlapping progbits LMAs. if (!link.CheckLMAOverlap()) return; // Output sections BinOutput out(os, m_object, diags); for (Object::section_iterator i=m_object.sections_begin(), end=m_object.sections_end(); i != end; ++i) { out.OutputSection(*i, origin); } }
void NumericOutput::EmitWarnings(Diagnostic& diags) const { if (m_sign && (m_warns & INT_OVERFLOW) != 0) diags.Report(m_source, diag::warn_signed_overflow) << m_size; if (!m_sign && (m_warns & INT_OVERFLOW) != 0) diags.Report(m_source, diag::warn_unsigned_overflow) << m_size; if ((m_warns & FP_UNDERFLOW) != 0) diags.Report(m_source, diag::warn_float_underflow); if ((m_warns & FP_OVERFLOW) != 0) diags.Report(m_source, diag::warn_float_overflow); if ((m_warns & TRUNCATED) != 0) diags.Report(m_source, diag::warn_truncated) << m_rshift; }
void Win64Object::DirProcFrame(DirectiveInfo& info, Diagnostic& diags) { assert(info.isObject(m_object)); NameValues& namevals = info.getNameValues(); SourceLocation source = info.getSource(); NameValue& name_nv = namevals.front(); if (!name_nv.isId()) { diags.Report(info.getSource(), diag::err_value_id) << name_nv.getValueRange(); return; } llvm::StringRef name = name_nv.getId(); if (m_proc_frame.isValid()) { diags.Report(info.getSource(), diags.getCustomDiagID(Diagnostic::Error, "nested procedures not supported (didn't use [ENDPROC_FRAME]?)")); diags.Report(m_proc_frame, diags.getCustomDiagID(Diagnostic::Note, "previous procedure started here")); return; } m_proc_frame = source; m_done_prolog = SourceLocation(); m_unwind.reset(new UnwindInfo); SymbolRef proc = m_object.getSymbol(name); proc->Use(source); m_unwind->setProc(proc); // Optional error handler if (namevals.size() > 1) { NameValue& ehandler_nv = namevals[1]; if (!ehandler_nv.isId()) { diags.Report(info.getSource(), diag::err_value_id) << ehandler_nv.getValueRange(); return; } SymbolRef ehandler = m_object.getSymbol(ehandler_nv.getId()); ehandler->Use(ehandler_nv.getValueRange().getBegin()); m_unwind->setEHandler(ehandler); } }
void Win64Object::DirPushReg(DirectiveInfo& info, Diagnostic& diags) { assert(info.isObject(m_object)); NameValues& namevals = info.getNameValues(); assert(!namevals.empty()); if (!CheckProcFrameState(info.getSource(), diags)) return; if (!namevals.front().isRegister()) { diags.Report(info.getSource(), diag::err_value_register) << namevals.front().getValueRange(); return; } const Register* reg = namevals.front().getRegister(); // Generate a PUSH_NONVOL unwind code. m_unwind->AddCode(std::auto_ptr<UnwindCode>(new UnwindCode( m_unwind->getProc(), m_object.getSymbol(info.getLocation()), UnwindCode::PUSH_NONVOL, reg->getNum() & 0xF))); }
bool yasm::DirNameValueWarn(NameValue& nv, SourceLocation dir_source, Diagnostic& diags) { if (nv.getNameSource().isValid()) { diags.Report(nv.getNameSource(), diag::warn_unrecognized_qualifier); return false; } diags.Report(nv.getValueRange().getBegin(), diag::warn_unrecognized_qualifier); return false; }
void Win64Object::DirAllocStack(DirectiveInfo& info, Diagnostic& diags) { assert(info.isObject(m_object)); NameValues& namevals = info.getNameValues(); assert(!namevals.empty()); if (!CheckProcFrameState(info.getSource(), diags)) return; NameValue& nv = namevals.front(); if (!nv.isExpr()) { diags.Report(info.getSource(), diag::err_value_expression) << nv.getValueRange(); return; } // Generate an ALLOC_SMALL unwind code; this will get enlarged to an // ALLOC_LARGE if necessary. m_unwind->AddCode(std::auto_ptr<UnwindCode>(new UnwindCode( m_unwind->getProc(), m_object.getSymbol(info.getLocation()), UnwindCode::ALLOC_SMALL, 0, 7, nv.ReleaseExpr(m_object)))); }
void ElfSymbol::Write(Bytes& bytes, const ElfConfig& config, Diagnostic& diags) { // Pull referenced elf symbol information type and size if (m_value_rel) { ElfSymbol* elfrel = m_value_rel->getAssocData<ElfSymbol>(); if (elfrel) { if (!hasType() && elfrel->hasType()) m_type = elfrel->m_type; if (!hasSize() && elfrel->hasSize()) { m_size = elfrel->m_size; m_size_source = elfrel->m_size_source; // just in case, simplify it SimplifyCalcDist(m_size, diags); if (!m_size.isIntNum()) diags.Report(m_size_source, diag::err_size_integer); } } } bytes.resize(0); config.setEndian(bytes); Write32(bytes, m_name_index); if (config.cls == ELFCLASS32) { Write32(bytes, m_value); Write32(bytes, hasSize() && m_size.isIntNum() ? m_size.getIntNum() : 0); } Write8(bytes, ELF_ST_INFO(m_bind, m_type)); Write8(bytes, ELF_ST_OTHER(m_vis)); if (m_sect) { ElfSection* elfsect = m_sect->getAssocData<ElfSection>(); assert(elfsect != 0); Write16(bytes, elfsect->getIndex()); } else { Write16(bytes, m_index); } if (config.cls == ELFCLASS64) { Write64(bytes, m_value); Write64(bytes, hasSize() ? m_size.getIntNum() : 0); } if (config.cls == ELFCLASS32) assert(bytes.size() == SYMTAB32_SIZE); else if (config.cls == ELFCLASS64) assert(bytes.size() == SYMTAB64_SIZE); }
void Win64Object::SaveCommon(DirectiveInfo& info, UnwindCode::Opcode op, Diagnostic& diags) { assert(info.isObject(m_object)); NameValues& namevals = info.getNameValues(); SourceLocation source = info.getSource(); assert(!namevals.empty()); if (!CheckProcFrameState(info.getSource(), diags)) return; if (!namevals.front().isRegister()) { diags.Report(source, diag::err_value_register) << namevals.front().getValueRange(); return; } const Register* reg = namevals.front().getRegister(); if (namevals.size() < 2) { diags.Report(source, diag::err_no_offset); return; } if (!namevals[1].isExpr()) { diags.Report(source, diag::err_offset_expression) << namevals[1].getValueRange(); return; } // Generate a SAVE_XXX unwind code; this will get enlarged to a // SAVE_XXX_FAR if necessary. m_unwind->AddCode(std::auto_ptr<UnwindCode>(new UnwindCode( m_unwind->getProc(), m_object.getSymbol(info.getLocation()), op, reg->getNum() & 0xF, 16, namevals[1].ReleaseExpr(m_object)))); }
// Initialize the remapping of files to alternative contents, e.g., // those specified through other files. static void InitializeFileRemapping(Diagnostic &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts) { // Remap files in the source manager. for (PreprocessorOptions::remapped_file_iterator Remap = InitOpts.remapped_file_begin(), RemapEnd = InitOpts.remapped_file_end(); Remap != RemapEnd; ++Remap) { // Find the file that we're mapping to. const FileEntry *ToFile = FileMgr.getFile(Remap->second); if (!ToFile) { Diags.Report(diag::err_fe_remap_missing_to_file) << Remap->first << Remap->second; continue; } // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, ToFile->getSize(), 0); if (!FromFile) { Diags.Report(diag::err_fe_remap_missing_from_file) << Remap->first; continue; } // Load the contents of the file we're mapping to. std::string ErrorStr; const llvm::MemoryBuffer *Buffer = llvm::MemoryBuffer::getFile(ToFile->getName(), &ErrorStr); if (!Buffer) { Diags.Report(diag::err_fe_error_opening) << Remap->second << ErrorStr; continue; } // Override the contents of the "from" file with the contents of // the "to" file. SourceMgr.overrideFileContents(FromFile, Buffer); } }
bool Multiple::CalcForOutput(SourceLocation source, Diagnostic& diags) { SimplifyCalcDist(m_expr, diags); if (!m_expr.isIntNum()) { diags.Report(source, diag::err_multiple_unknown); return false; } IntNum num = m_expr.getIntNum(); if (num.getSign() < 0) { diags.Report(source, diag::err_multiple_negative); return false; } assert(m_int == num.getInt() && "multiple changed after optimize"); m_int = num.getInt(); return true; }
bool BinObject::setMapFilename(const NameValue& nv, SourceLocation dir_source, Diagnostic& diags) { if (!m_map_filename.empty()) { diags.Report(nv.getValueRange().getBegin(), diags.getCustomDiagID(Diagnostic::Error, "map file already specified")); return true; } if (!nv.isString()) { diags.Report(nv.getValueRange().getBegin(), diag::err_value_string_or_id); return false; } m_map_filename = nv.getString(); return true; }
static int getLastArgIntValue(ArgList &Args, cc1options::ID ID, int Default, Diagnostic &Diags) { Arg *A = Args.getLastArg(ID); if (!A) return Default; int Res = Default; if (llvm::StringRef(A->getValue(Args)).getAsInteger(10, Res)) Diags.Report(diag::err_drv_invalid_int_value) << A->getAsString(Args) << A->getValue(Args); return Res; }
bool Win64Object::CheckProcFrameState(SourceLocation dir_source, Diagnostic& diags) { if (!m_proc_frame.isValid()) { diags.Report(dir_source, diags.getCustomDiagID(Diagnostic::Error, "no preceding [PROC_FRAME]")); return false; } if (m_done_prolog.isValid()) { diags.Report(dir_source, diags.getCustomDiagID(Diagnostic::Error, "must come before [END_PROLOGUE]")); diags.Report(m_done_prolog, diags.getCustomDiagID(Diagnostic::Note, "prologue ended here")); return false; } return true; }
static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, Diagnostic &Diags) { using namespace cc1options; Opts.ImplicitPCHInclude = getLastArgValue(Args, OPT_include_pch); Opts.ImplicitPTHInclude = getLastArgValue(Args, OPT_include_pth); if (const Arg *A = Args.getLastArg(OPT_token_cache)) Opts.TokenCache = A->getValue(Args); else Opts.TokenCache = Opts.ImplicitPTHInclude; Opts.UsePredefines = !Args.hasArg(OPT_undef); // Add macros from the command line. for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U), ie = Args.filtered_end(); it != ie; ++it) { if (it->getOption().matches(OPT_D)) Opts.addMacroDef(it->getValue(Args)); else Opts.addMacroUndef(it->getValue(Args)); } Opts.MacroIncludes = getAllArgValues(Args, OPT_imacros); // Add the ordered list of -includes. for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch, OPT_include_pth), ie = Args.filtered_end(); it != ie; ++it) { // PCH is handled specially, we need to extra the original include path. if (it->getOption().matches(OPT_include_pch)) { std::string OriginalFile = PCHReader::getOriginalSourceFile(it->getValue(Args), Diags); if (OriginalFile.empty()) continue; Opts.Includes.push_back(OriginalFile); } else Opts.Includes.push_back(it->getValue(Args)); } for (arg_iterator it = Args.filtered_begin(OPT_remap_file), ie = Args.filtered_end(); it != ie; ++it) { std::pair<llvm::StringRef,llvm::StringRef> Split = llvm::StringRef(it->getValue(Args)).split(';'); if (Split.second.empty()) { Diags.Report(diag::err_drv_invalid_remap_file) << it->getAsString(Args); continue; } Opts.addRemappedFile(Split.first, Split.second); } }
void BinObject::DirOrg(DirectiveInfo& info, Diagnostic& diags) { // We only allow a single ORG in a program. if (m_org.get() != 0) { diags.Report(info.getSource(), diags.getCustomDiagID(Diagnostic::Error, "program origin redefined")); return; } // ORG takes just a simple expression as param const NameValue& nv = info.getNameValues().front(); if (!nv.isExpr()) { diags.Report(info.getSource(), diag::err_value_expression) << nv.getValueRange(); return; } m_org.reset(new Expr(nv.getExpr(info.getObject()))); m_org_source = info.getSource(); }
ElfSymbol::ElfSymbol(const ElfConfig& config, const llvm::MemoryBuffer& in, const ElfSection& symtab_sect, ElfSymbolIndex index, Section* sections[], Diagnostic& diags) : m_sect(0) , m_name_index(0) , m_value(0) , m_symindex(index) , m_in_table(true) , m_weak_ref(false) , m_weak_refr(false) { InputBuffer inbuf(in); ElfSize symsize = symtab_sect.getEntSize(); inbuf.setPosition(symtab_sect.getFileOffset() + index * symsize); if (inbuf.getReadableSize() < symsize) { diags.Report(SourceLocation(), diag::err_symbol_unreadable); return; } config.setEndian(inbuf); m_name_index = ReadU32(inbuf); if (config.cls == ELFCLASS32) { m_value = ReadU32(inbuf); m_size = Expr(ReadU32(inbuf)); } unsigned char info = ReadU8(inbuf); m_bind = ELF_ST_BIND(info); m_type = ELF_ST_TYPE(info); m_vis = ELF_ST_VISIBILITY(ReadU8(inbuf)); m_index = static_cast<ElfSectionIndex>(ReadU16(inbuf)); if (m_index != SHN_UNDEF && m_index < config.secthead_count) m_sect = sections[m_index]; if (config.cls == ELFCLASS64) { m_value = ReadU64(inbuf); m_size = Expr(ReadU64(inbuf)); } }
void yasm::DirRegister(NameValue& nv, Diagnostic& diags, RegisterPtr* out, bool* out_set) { if (!nv.isRegister()) { diags.Report(nv.getNameSource(), diag::err_value_register) << nv.getValueRange(); return; } *out = nv.getRegister(); *out_set = true; }
void yasm::DirString(NameValue& nv, Diagnostic& diags, std::string* out, bool* out_set) { if (!nv.isString()) { diags.Report(nv.getNameSource(), diag::err_value_string_or_id) << nv.getValueRange(); return; } *out = nv.getString(); *out_set = true; }
bool Multiple::CalcLen(Bytecode& bc, const Bytecode::AddSpanFunc& add_span, Diagnostic& diags) { // Calculate multiple value as an integer m_int = 1; if (m_expr.isIntNum()) { IntNum num = m_expr.getIntNum(); if (num.getSign() < 0) { m_int = 0; diags.Report(bc.getSource(), diag::err_multiple_negative); return false; } else m_int = num.getInt(); } else { if (m_expr.Contains(ExprTerm::FLOAT)) { m_int = 0; diags.Report(bc.getSource(), diag::err_expr_contains_float); return false; } else { Value value(0, Expr::Ptr(m_expr.clone())); add_span(bc, 0, value, 0, 0); m_int = 0; // assume 0 to start } } return true; }
static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, Diagnostic &Diags) { using namespace cc1options; // -Os implies -O2 if (Args.hasArg(OPT_Os)) Opts.OptimizationLevel = 2; else { Opts.OptimizationLevel = getLastArgIntValue(Args, OPT_O, 0, Diags); if (Opts.OptimizationLevel > 3) { Diags.Report(diag::err_drv_invalid_value) << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel; Opts.OptimizationLevel = 3; } } // We must always run at least the always inlining pass. Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining : CodeGenOptions::OnlyAlwaysInlining; Opts.DebugInfo = Args.hasArg(OPT_g); Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns); Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone); Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants); Opts.NoCommon = Args.hasArg(OPT_fno_common); Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float); Opts.OptimizeSize = Args.hasArg(OPT_Os); Opts.UnrollLoops = (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize); Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose); Opts.CodeModel = getLastArgValue(Args, OPT_mcode_model); Opts.DebugPass = getLastArgValue(Args, OPT_mdebug_pass); Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim); Opts.FloatABI = getLastArgValue(Args, OPT_mfloat_abi); Opts.LimitFloatPrecision = getLastArgValue(Args, OPT_mlimit_float_precision); Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss); Opts.SoftFloat = Args.hasArg(OPT_msoft_float); Opts.UnwindTables = Args.hasArg(OPT_munwind_tables); Opts.RelocationModel = getLastArgValue(Args, OPT_mrelocation_model, "pic"); Opts.MainFileName = getLastArgValue(Args, OPT_main_file_name); // FIXME: Put elsewhere? #ifdef NDEBUG Opts.VerifyModule = 0; #else Opts.VerifyModule = 1; #endif }
void yasm::DirExpr(NameValue& nv, Diagnostic& diags, Object* obj, std::auto_ptr<Expr>* out, bool* out_set) { if (!nv.isExpr()) { diags.Report(nv.getNameSource(), diag::err_value_expression) << nv.getValueRange(); return; } *out = nv.ReleaseExpr(*obj); *out_set = true; }
// Append a #define line to Buf for Macro. Macro should be of the form XXX, // in which case we emit "#define XXX 1" or "XXX=Y z W" in which case we emit // "#define XXX Y z W". To get a #define with no value, use "XXX=". static void DefineBuiltinMacro(MacroBuilder &Builder, llvm::StringRef Macro, Diagnostic &Diags) { std::pair<llvm::StringRef, llvm::StringRef> MacroPair = Macro.split('='); llvm::StringRef MacroName = MacroPair.first; llvm::StringRef MacroBody = MacroPair.second; if (MacroName.size() != Macro.size()) { // Per GCC -D semantics, the macro ends at \n if it exists. llvm::StringRef::size_type End = MacroBody.find_first_of("\n\r"); if (End != llvm::StringRef::npos) Diags.Report(diag::warn_fe_macro_contains_embedded_newline) << MacroName; Builder.defineMacro(MacroName, MacroBody.substr(0, End)); } else { // Push "macroname 1". Builder.defineMacro(Macro); } }