utils/TableGen/LLVMCConfigurationEmitter.cpp

   1 //===- LLVMCConfigurationEmitter.cpp - Generate LLVMC config ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open
   6 // Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This tablegen backend is responsible for emitting LLVMC configuration code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "LLVMCConfigurationEmitter.h"
  15 #include "Record.h"
  16
  17 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/StringSet.h"
  22 #include <algorithm>
  23 #include <cassert>
  24 #include <functional>
  25 #include <stdexcept>
  26 #include <string>
  27 #include <typeinfo>
  28
  29 using namespace llvm;
  30
  31 namespace {
  32
  33 //===----------------------------------------------------------------------===//
  34 /// Typedefs
  35
  36 typedef std::vector<Record*> RecordVector;
  37 typedef std::vector<std::string> StrVector;
  38
  39 //===----------------------------------------------------------------------===//
  40 /// Constants
  41
  42 // Indentation strings.
  43 const char * Indent1 = "    ";
  44 const char * Indent2 = "        ";
  45 const char * Indent3 = "            ";
  46
  47 // Default help string.
  48 const char * DefaultHelpString = "NO HELP MESSAGE PROVIDED";
  49
  50 // Name for the "sink" option.
  51 const char * SinkOptionName = "AutoGeneratedSinkOption";
  52
  53 //===----------------------------------------------------------------------===//
  54 /// Helper functions
  55
  56 /// Id - An 'identity' function object.
  57 struct Id {
  58   template<typename T>
  59   void operator()(const T&) const {
  60   }
  61 };
  62
  63 int InitPtrToInt(const Init* ptr) {
  64   const IntInit& val = dynamic_cast<const IntInit&>(*ptr);
  65   return val.getValue();
  66 }
  67
  68 const std::string& InitPtrToString(const Init* ptr) {
  69   const StringInit& val = dynamic_cast<const StringInit&>(*ptr);
  70   return val.getValue();
  71 }
  72
  73 const ListInit& InitPtrToList(const Init* ptr) {
  74   const ListInit& val = dynamic_cast<const ListInit&>(*ptr);
  75   return val;
  76 }
  77
  78 const DagInit& InitPtrToDag(const Init* ptr) {
  79   const DagInit& val = dynamic_cast<const DagInit&>(*ptr);
  80   return val;
  81 }
  82
  83 // checkNumberOfArguments - Ensure that the number of args in d is
  84 // greater than or equal to min_arguments, otherwise throw an exception.
  85 void checkNumberOfArguments (const DagInit* d, unsigned min_arguments) {
  86   if (!d || d->getNumArgs() < min_arguments)
  87     throw d->getOperator()->getAsString() + ": too few arguments!";
  88 }
  89
  90 // isDagEmpty - is this DAG marked with an empty marker?
  91 bool isDagEmpty (const DagInit* d) {
  92   return d->getOperator()->getAsString() == "empty";
  93 }
  94
  95 // EscapeVariableName - Escape commas and other symbols not allowed
  96 // in the C++ variable names. Makes it possible to use options named
  97 // like "Wa," (useful for prefix options).
  98 std::string EscapeVariableName(const std::string& Var) {
  99   std::string ret;
 100   for (unsigned i = 0; i != Var.size(); ++i) {
 101     char cur_char = Var[i];
 102     if (cur_char == ',') {
 103       ret += "_comma_";
 104     }
 105     else if (cur_char == '+') {
 106       ret += "_plus_";
 107     }
 108     else if (cur_char == '-') {
 109       ret += "_dash_";
 110     }
 111     else {
 112       ret.push_back(cur_char);
 113     }
 114   }
 115   return ret;
 116 }
 117
 118 /// oneOf - Does the input string contain this character?
 119 bool oneOf(const char* lst, char c) {
 120   while (*lst) {
 121     if (*lst++ == c)
 122       return true;
 123   }
 124   return false;
 125 }
 126
 127 template <class I, class S>
 128 void checkedIncrement(I& P, I E, S ErrorString) {
 129   ++P;
 130   if (P == E)
 131     throw ErrorString;
 132 }
 133
 134 //===----------------------------------------------------------------------===//
 135 /// Back-end specific code
 136
 137
 138 /// OptionType - One of six different option types. See the
 139 /// documentation for detailed description of differences.
 140 namespace OptionType {
 141
 142   enum OptionType { Alias, Switch, Parameter, ParameterList,
 143                     Prefix, PrefixList};
 144
 145   bool IsList (OptionType t) {
 146     return (t == ParameterList || t == PrefixList);
 147   }
 148
 149   bool IsSwitch (OptionType t) {
 150     return (t == Switch);
 151   }
 152
 153   bool IsParameter (OptionType t) {
 154     return (t == Parameter || t == Prefix);
 155   }
 156
 157 }
 158
 159 OptionType::OptionType stringToOptionType(const std::string& T) {
 160   if (T == "alias_option")
 161     return OptionType::Alias;
 162   else if (T == "switch_option")
 163     return OptionType::Switch;
 164   else if (T == "parameter_option")
 165     return OptionType::Parameter;
 166   else if (T == "parameter_list_option")
 167     return OptionType::ParameterList;
 168   else if (T == "prefix_option")
 169     return OptionType::Prefix;
 170   else if (T == "prefix_list_option")
 171     return OptionType::PrefixList;
 172   else
 173     throw "Unknown option type: " + T + '!';
 174 }
 175
 176 namespace OptionDescriptionFlags {
 177   enum OptionDescriptionFlags { Required = 0x1, Hidden = 0x2,
 178                                 ReallyHidden = 0x4, Extern = 0x8,
 179                                 OneOrMore = 0x10, ZeroOrOne = 0x20 };
 180 }
 181
 182 /// OptionDescription - Represents data contained in a single
 183 /// OptionList entry.
 184 struct OptionDescription {
 185   OptionType::OptionType Type;
 186   std::string Name;
 187   unsigned Flags;
 188   std::string Help;
 189   unsigned MultiVal;
 190   Init* InitVal;
 191
 192   OptionDescription(OptionType::OptionType t = OptionType::Switch,
 193                     const std::string& n = "",
 194                     const std::string& h = DefaultHelpString)
 195     : Type(t), Name(n), Flags(0x0), Help(h), MultiVal(1), InitVal(0)
 196   {}
 197
 198   /// GenTypeDeclaration - Returns the C++ variable type of this
 199   /// option.
 200   const char* GenTypeDeclaration() const;
 201
 202   /// GenVariableName - Returns the variable name used in the
 203   /// generated C++ code.
 204   std::string GenVariableName() const;
 205
 206   /// Merge - Merge two option descriptions.
 207   void Merge (const OptionDescription& other);
 208
 209   // Misc convenient getters/setters.
 210
 211   bool isAlias() const;
 212
 213   bool isMultiVal() const;
 214
 215   bool isExtern() const;
 216   void setExtern();
 217
 218   bool isRequired() const;
 219   void setRequired();
 220
 221   bool isOneOrMore() const;
 222   void setOneOrMore();
 223
 224   bool isZeroOrOne() const;
 225   void setZeroOrOne();
 226
 227   bool isHidden() const;
 228   void setHidden();
 229
 230   bool isReallyHidden() const;
 231   void setReallyHidden();
 232
 233   bool isParameter() const
 234   { return OptionType::IsParameter(this->Type); }
 235
 236   bool isSwitch() const
 237   { return OptionType::IsSwitch(this->Type); }
 238
 239   bool isList() const
 240   { return OptionType::IsList(this->Type); }
 241
 242 };
 243
 244 void OptionDescription::Merge (const OptionDescription& other)
 245 {
 246   if (other.Type != Type)
 247     throw "Conflicting definitions for the option " + Name + "!";
 248
 249   if (Help == other.Help || Help == DefaultHelpString)
 250     Help = other.Help;
 251   else if (other.Help != DefaultHelpString) {
 252     llvm::errs() << "Warning: several different help strings"
 253       " defined for option " + Name + "\n";
 254   }
 255
 256   Flags |= other.Flags;
 257 }
 258
 259 bool OptionDescription::isAlias() const {
 260   return Type == OptionType::Alias;
 261 }
 262
 263 bool OptionDescription::isMultiVal() const {
 264   return MultiVal > 1;
 265 }
 266
 267 bool OptionDescription::isExtern() const {
 268   return Flags & OptionDescriptionFlags::Extern;
 269 }
 270 void OptionDescription::setExtern() {
 271   Flags |= OptionDescriptionFlags::Extern;
 272 }
 273
 274 bool OptionDescription::isRequired() const {
 275   return Flags & OptionDescriptionFlags::Required;
 276 }
 277 void OptionDescription::setRequired() {
 278   Flags |= OptionDescriptionFlags::Required;
 279 }
 280
 281 bool OptionDescription::isOneOrMore() const {
 282   return Flags & OptionDescriptionFlags::OneOrMore;
 283 }
 284 void OptionDescription::setOneOrMore() {
 285   Flags |= OptionDescriptionFlags::OneOrMore;
 286 }
 287
 288 bool OptionDescription::isZeroOrOne() const {
 289   return Flags & OptionDescriptionFlags::ZeroOrOne;
 290 }
 291 void OptionDescription::setZeroOrOne() {
 292   Flags |= OptionDescriptionFlags::ZeroOrOne;
 293 }
 294
 295 bool OptionDescription::isHidden() const {
 296   return Flags & OptionDescriptionFlags::Hidden;
 297 }
 298 void OptionDescription::setHidden() {
 299   Flags |= OptionDescriptionFlags::Hidden;
 300 }
 301
 302 bool OptionDescription::isReallyHidden() const {
 303   return Flags & OptionDescriptionFlags::ReallyHidden;
 304 }
 305 void OptionDescription::setReallyHidden() {
 306   Flags |= OptionDescriptionFlags::ReallyHidden;
 307 }
 308
 309 const char* OptionDescription::GenTypeDeclaration() const {
 310   switch (Type) {
 311   case OptionType::Alias:
 312     return "cl::alias";
 313   case OptionType::PrefixList:
 314   case OptionType::ParameterList:
 315     return "cl::list<std::string>";
 316   case OptionType::Switch:
 317     return "cl::opt<bool>";
 318   case OptionType::Parameter:
 319   case OptionType::Prefix:
 320   default:
 321     return "cl::opt<std::string>";
 322   }
 323 }
 324
 325 std::string OptionDescription::GenVariableName() const {
 326   const std::string& EscapedName = EscapeVariableName(Name);
 327   switch (Type) {
 328   case OptionType::Alias:
 329     return "AutoGeneratedAlias_" + EscapedName;
 330   case OptionType::PrefixList:
 331   case OptionType::ParameterList:
 332     return "AutoGeneratedList_" + EscapedName;
 333   case OptionType::Switch:
 334     return "AutoGeneratedSwitch_" + EscapedName;
 335   case OptionType::Prefix:
 336   case OptionType::Parameter:
 337   default:
 338     return "AutoGeneratedParameter_" + EscapedName;
 339   }
 340 }
 341
 342 /// OptionDescriptions - An OptionDescription array plus some helper
 343 /// functions.
 344 class OptionDescriptions {
 345   typedef StringMap<OptionDescription> container_type;
 346
 347   /// Descriptions - A list of OptionDescriptions.
 348   container_type Descriptions;
 349
 350 public:
 351   /// FindOption - exception-throwing wrapper for find().
 352   const OptionDescription& FindOption(const std::string& OptName) const;
 353
 354   /// insertDescription - Insert new OptionDescription into
 355   /// OptionDescriptions list
 356   void InsertDescription (const OptionDescription& o);
 357
 358   // Support for STL-style iteration
 359   typedef container_type::const_iterator const_iterator;
 360   const_iterator begin() const { return Descriptions.begin(); }
 361   const_iterator end() const { return Descriptions.end(); }
 362 };
 363
 364 const OptionDescription&
 365 OptionDescriptions::FindOption(const std::string& OptName) const
 366 {
 367   const_iterator I = Descriptions.find(OptName);
 368   if (I != Descriptions.end())
 369     return I->second;
 370   else
 371     throw OptName + ": no such option!";
 372 }
 373
 374 void OptionDescriptions::InsertDescription (const OptionDescription& o)
 375 {
 376   container_type::iterator I = Descriptions.find(o.Name);
 377   if (I != Descriptions.end()) {
 378     OptionDescription& D = I->second;
 379     D.Merge(o);
 380   }
 381   else {
 382     Descriptions[o.Name] = o;
 383   }
 384 }
 385
 386 /// HandlerTable - A base class for function objects implemented as
 387 /// 'tables of handlers'.
 388 template <class T>
 389 class HandlerTable {
 390 protected:
 391   // Implementation details.
 392
 393   /// Handler -
 394   typedef void (T::* Handler) (const DagInit*);
 395   /// HandlerMap - A map from property names to property handlers
 396   typedef StringMap<Handler> HandlerMap;
 397
 398   static HandlerMap Handlers_;
 399   static bool staticMembersInitialized_;
 400
 401   T* childPtr;
 402 public:
 403
 404   HandlerTable(T* cp) : childPtr(cp)
 405   {}
 406
 407   /// operator() - Just forwards to the corresponding property
 408   /// handler.
 409   void operator() (Init* i) {
 410     const DagInit& property = InitPtrToDag(i);
 411     const std::string& property_name = property.getOperator()->getAsString();
 412     typename HandlerMap::iterator method = Handlers_.find(property_name);
 413
 414     if (method != Handlers_.end()) {
 415       Handler h = method->second;
 416       (childPtr->*h)(&property);
 417     }
 418     else {
 419       throw "No handler found for property " + property_name + "!";
 420     }
 421   }
 422
 423   void AddHandler(const char* Property, Handler Handl) {
 424     Handlers_[Property] = Handl;
 425   }
 426 };
 427
 428 template <class T> typename HandlerTable<T>::HandlerMap
 429 HandlerTable<T>::Handlers_;
 430 template <class T> bool HandlerTable<T>::staticMembersInitialized_ = false;
 431
 432
 433 /// CollectOptionProperties - Function object for iterating over an
 434 /// option property list.
 435 class CollectOptionProperties : public HandlerTable<CollectOptionProperties> {
 436 private:
 437
 438   /// optDescs_ - OptionDescriptions table. This is where the
 439   /// information is stored.
 440   OptionDescription& optDesc_;
 441
 442 public:
 443
 444   explicit CollectOptionProperties(OptionDescription& OD)
 445     : HandlerTable<CollectOptionProperties>(this), optDesc_(OD)
 446   {
 447     if (!staticMembersInitialized_) {
 448       AddHandler("extern", &CollectOptionProperties::onExtern);
 449       AddHandler("help", &CollectOptionProperties::onHelp);
 450       AddHandler("hidden", &CollectOptionProperties::onHidden);
 451       AddHandler("init", &CollectOptionProperties::onInit);
 452       AddHandler("multi_val", &CollectOptionProperties::onMultiVal);
 453       AddHandler("one_or_more", &CollectOptionProperties::onOneOrMore);
 454       AddHandler("really_hidden", &CollectOptionProperties::onReallyHidden);
 455       AddHandler("required", &CollectOptionProperties::onRequired);
 456       AddHandler("zero_or_one", &CollectOptionProperties::onZeroOrOne);
 457
 458       staticMembersInitialized_ = true;
 459     }
 460   }
 461
 462 private:
 463
 464   /// Option property handlers --
 465   /// Methods that handle option properties such as (help) or (hidden).
 466
 467   void onExtern (const DagInit* d) {
 468     checkNumberOfArguments(d, 0);
 469     optDesc_.setExtern();
 470   }
 471
 472   void onHelp (const DagInit* d) {
 473     checkNumberOfArguments(d, 1);
 474     optDesc_.Help = InitPtrToString(d->getArg(0));
 475   }
 476
 477   void onHidden (const DagInit* d) {
 478     checkNumberOfArguments(d, 0);
 479     optDesc_.setHidden();
 480   }
 481
 482   void onReallyHidden (const DagInit* d) {
 483     checkNumberOfArguments(d, 0);
 484     optDesc_.setReallyHidden();
 485   }
 486
 487   void onRequired (const DagInit* d) {
 488     checkNumberOfArguments(d, 0);
 489     if (optDesc_.isOneOrMore())
 490       throw std::string("An option can't have both (required) "
 491                         "and (one_or_more) properties!");
 492     optDesc_.setRequired();
 493   }
 494
 495   void onInit (const DagInit* d) {
 496     checkNumberOfArguments(d, 1);
 497     Init* i = d->getArg(0);
 498     const std::string& str = i->getAsString();
 499
 500     bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
 501     correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
 502
 503     if (!correct)
 504       throw std::string("Incorrect usage of the 'init' option property!");
 505
 506     optDesc_.InitVal = i;
 507   }
 508
 509   void onOneOrMore (const DagInit* d) {
 510     checkNumberOfArguments(d, 0);
 511     if (optDesc_.isRequired() || optDesc_.isZeroOrOne())
 512       throw std::string("Only one of (required), (zero_or_one) or "
 513                         "(one_or_more) properties is allowed!");
 514     if (!OptionType::IsList(optDesc_.Type))
 515       llvm::errs() << "Warning: specifying the 'one_or_more' property "
 516         "on a non-list option will have no effect.\n";
 517     optDesc_.setOneOrMore();
 518   }
 519
 520   void onZeroOrOne (const DagInit* d) {
 521     checkNumberOfArguments(d, 0);
 522     if (optDesc_.isRequired() || optDesc_.isOneOrMore())
 523       throw std::string("Only one of (required), (zero_or_one) or "
 524                         "(one_or_more) properties is allowed!");
 525     if (!OptionType::IsList(optDesc_.Type))
 526       llvm::errs() << "Warning: specifying the 'zero_or_one' property"
 527         "on a non-list option will have no effect.\n";
 528     optDesc_.setZeroOrOne();
 529   }
 530
 531   void onMultiVal (const DagInit* d) {
 532     checkNumberOfArguments(d, 1);
 533     int val = InitPtrToInt(d->getArg(0));
 534     if (val < 2)
 535       throw std::string("Error in the 'multi_val' property: "
 536                         "the value must be greater than 1!");
 537     if (!OptionType::IsList(optDesc_.Type))
 538       throw std::string("The multi_val property is valid only "
 539                         "on list options!");
 540     optDesc_.MultiVal = val;
 541   }
 542
 543 };
 544
 545 /// AddOption - A function object that is applied to every option
 546 /// description. Used by CollectOptionDescriptions.
 547 class AddOption {
 548 private:
 549   OptionDescriptions& OptDescs_;
 550
 551 public:
 552   explicit AddOption(OptionDescriptions& OD) : OptDescs_(OD)
 553   {}
 554
 555   void operator()(const Init* i) {
 556     const DagInit& d = InitPtrToDag(i);
 557     checkNumberOfArguments(&d, 1);
 558
 559     const OptionType::OptionType Type =
 560       stringToOptionType(d.getOperator()->getAsString());
 561     const std::string& Name = InitPtrToString(d.getArg(0));
 562
 563     OptionDescription OD(Type, Name);
 564
 565     if (!OD.isExtern())
 566       checkNumberOfArguments(&d, 2);
 567
 568     if (OD.isAlias()) {
 569       // Aliases store the aliased option name in the 'Help' field.
 570       OD.Help = InitPtrToString(d.getArg(1));
 571     }
 572     else if (!OD.isExtern()) {
 573       processOptionProperties(&d, OD);
 574     }
 575     OptDescs_.InsertDescription(OD);
 576   }
 577
 578 private:
 579   /// processOptionProperties - Go through the list of option
 580   /// properties and call a corresponding handler for each.
 581   static void processOptionProperties (const DagInit* d, OptionDescription& o) {
 582     checkNumberOfArguments(d, 2);
 583     DagInit::const_arg_iterator B = d->arg_begin();
 584     // Skip the first argument: it's always the option name.
 585     ++B;
 586     std::for_each(B, d->arg_end(), CollectOptionProperties(o));
 587   }
 588
 589 };
 590
 591 /// CollectOptionDescriptions - Collects option properties from all
 592 /// OptionLists.
 593 void CollectOptionDescriptions (RecordVector::const_iterator B,
 594                                 RecordVector::const_iterator E,
 595                                 OptionDescriptions& OptDescs)
 596 {
 597   // For every OptionList:
 598   for (; B!=E; ++B) {
 599     RecordVector::value_type T = *B;
 600     // Throws an exception if the value does not exist.
 601     ListInit* PropList = T->getValueAsListInit("options");
 602
 603     // For every option description in this list:
 604     // collect the information and
 605     std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
 606   }
 607 }
 608
 609 // Tool information record
 610
 611 namespace ToolFlags {
 612   enum ToolFlags { Join = 0x1, Sink = 0x2 };
 613 }
 614
 615 struct ToolDescription : public RefCountedBase<ToolDescription> {
 616   std::string Name;
 617   Init* CmdLine;
 618   Init* Actions;
 619   StrVector InLanguage;
 620   std::string OutLanguage;
 621   std::string OutputSuffix;
 622   unsigned Flags;
 623
 624   // Various boolean properties
 625   void setSink()      { Flags |= ToolFlags::Sink; }
 626   bool isSink() const { return Flags & ToolFlags::Sink; }
 627   void setJoin()      { Flags |= ToolFlags::Join; }
 628   bool isJoin() const { return Flags & ToolFlags::Join; }
 629
 630   // Default ctor here is needed because StringMap can only store
 631   // DefaultConstructible objects
 632   ToolDescription() : CmdLine(0), Actions(0), Flags(0) {}
 633   ToolDescription (const std::string& n)
 634   : Name(n), CmdLine(0), Actions(0), Flags(0)
 635   {}
 636 };
 637
 638 /// ToolDescriptions - A list of Tool information records.
 639 typedef std::vector<IntrusiveRefCntPtr<ToolDescription> > ToolDescriptions;
 640
 641
 642 /// CollectToolProperties - Function object for iterating over a list of
 643 /// tool property records.
 644 class CollectToolProperties : public HandlerTable<CollectToolProperties> {
 645 private:
 646
 647   /// toolDesc_ - Properties of the current Tool. This is where the
 648   /// information is stored.
 649   ToolDescription& toolDesc_;
 650
 651 public:
 652
 653   explicit CollectToolProperties (ToolDescription& d)
 654     : HandlerTable<CollectToolProperties>(this) , toolDesc_(d)
 655   {
 656     if (!staticMembersInitialized_) {
 657
 658       AddHandler("actions", &CollectToolProperties::onActions);
 659       AddHandler("cmd_line", &CollectToolProperties::onCmdLine);
 660       AddHandler("in_language", &CollectToolProperties::onInLanguage);
 661       AddHandler("join", &CollectToolProperties::onJoin);
 662       AddHandler("out_language", &CollectToolProperties::onOutLanguage);
 663       AddHandler("output_suffix", &CollectToolProperties::onOutputSuffix);
 664       AddHandler("sink", &CollectToolProperties::onSink);
 665
 666       staticMembersInitialized_ = true;
 667     }
 668   }
 669
 670 private:
 671
 672   /// Property handlers --
 673   /// Functions that extract information about tool properties from
 674   /// DAG representation.
 675
 676   void onActions (const DagInit* d) {
 677     checkNumberOfArguments(d, 1);
 678     Init* Case = d->getArg(0);
 679     if (typeid(*Case) != typeid(DagInit) ||
 680         static_cast<DagInit*>(Case)->getOperator()->getAsString() != "case")
 681       throw
 682         std::string("The argument to (actions) should be a 'case' construct!");
 683     toolDesc_.Actions = Case;
 684   }
 685
 686   void onCmdLine (const DagInit* d) {
 687     checkNumberOfArguments(d, 1);
 688     toolDesc_.CmdLine = d->getArg(0);
 689   }
 690
 691   void onInLanguage (const DagInit* d) {
 692     checkNumberOfArguments(d, 1);
 693     Init* arg = d->getArg(0);
 694
 695     // Find out the argument's type.
 696     if (typeid(*arg) == typeid(StringInit)) {
 697       // It's a string.
 698       toolDesc_.InLanguage.push_back(InitPtrToString(arg));
 699     }
 700     else {
 701       // It's a list.
 702       const ListInit& lst = InitPtrToList(arg);
 703       StrVector& out = toolDesc_.InLanguage;
 704
 705       // Copy strings to the output vector.
 706       for (ListInit::const_iterator B = lst.begin(), E = lst.end();
 707            B != E; ++B) {
 708         out.push_back(InitPtrToString(*B));
 709       }
 710
 711       // Remove duplicates.
 712       std::sort(out.begin(), out.end());
 713       StrVector::iterator newE = std::unique(out.begin(), out.end());
 714       out.erase(newE, out.end());
 715     }
 716   }
 717
 718   void onJoin (const DagInit* d) {
 719     checkNumberOfArguments(d, 0);
 720     toolDesc_.setJoin();
 721   }
 722
 723   void onOutLanguage (const DagInit* d) {
 724     checkNumberOfArguments(d, 1);
 725     toolDesc_.OutLanguage = InitPtrToString(d->getArg(0));
 726   }
 727
 728   void onOutputSuffix (const DagInit* d) {
 729     checkNumberOfArguments(d, 1);
 730     toolDesc_.OutputSuffix = InitPtrToString(d->getArg(0));
 731   }
 732
 733   void onSink (const DagInit* d) {
 734     checkNumberOfArguments(d, 0);
 735     toolDesc_.setSink();
 736   }
 737
 738 };
 739
 740 /// CollectToolDescriptions - Gather information about tool properties
 741 /// from the parsed TableGen data (basically a wrapper for the
 742 /// CollectToolProperties function object).
 743 void CollectToolDescriptions (RecordVector::const_iterator B,
 744                               RecordVector::const_iterator E,
 745                               ToolDescriptions& ToolDescs)
 746 {
 747   // Iterate over a properties list of every Tool definition
 748   for (;B!=E;++B) {
 749     const Record* T = *B;
 750     // Throws an exception if the value does not exist.
 751     ListInit* PropList = T->getValueAsListInit("properties");
 752
 753     IntrusiveRefCntPtr<ToolDescription>
 754       ToolDesc(new ToolDescription(T->getName()));
 755
 756     std::for_each(PropList->begin(), PropList->end(),
 757                   CollectToolProperties(*ToolDesc));
 758     ToolDescs.push_back(ToolDesc);
 759   }
 760 }
 761
 762 /// FillInEdgeVector - Merge all compilation graph definitions into
 763 /// one single edge list.
 764 void FillInEdgeVector(RecordVector::const_iterator B,
 765                       RecordVector::const_iterator E, RecordVector& Out) {
 766   for (; B != E; ++B) {
 767     const ListInit* edges = (*B)->getValueAsListInit("edges");
 768
 769     for (unsigned i = 0; i < edges->size(); ++i)
 770       Out.push_back(edges->getElementAsRecord(i));
 771   }
 772 }
 773
 774 /// CalculatePriority - Calculate the priority of this plugin.
 775 int CalculatePriority(RecordVector::const_iterator B,
 776                       RecordVector::const_iterator E) {
 777   int total = 0;
 778   for (; B!=E; ++B) {
 779     total += static_cast<int>((*B)->getValueAsInt("priority"));
 780   }
 781   return total;
 782 }
 783
 784 /// NotInGraph - Helper function object for FilterNotInGraph.
 785 struct NotInGraph {
 786 private:
 787   const llvm::StringSet<>& ToolsInGraph_;
 788
 789 public:
 790   NotInGraph(const llvm::StringSet<>& ToolsInGraph)
 791   : ToolsInGraph_(ToolsInGraph)
 792   {}
 793
 794   bool operator()(const IntrusiveRefCntPtr<ToolDescription>& x) {
 795     return (ToolsInGraph_.count(x->Name) == 0);
 796   }
 797 };
 798
 799 /// FilterNotInGraph - Filter out from ToolDescs all Tools not
 800 /// mentioned in the compilation graph definition.
 801 void FilterNotInGraph (const RecordVector& EdgeVector,
 802                        ToolDescriptions& ToolDescs) {
 803
 804   // List all tools mentioned in the graph.
 805   llvm::StringSet<> ToolsInGraph;
 806
 807   for (RecordVector::const_iterator B = EdgeVector.begin(),
 808          E = EdgeVector.end(); B != E; ++B) {
 809
 810     const Record* Edge = *B;
 811     const std::string& NodeA = Edge->getValueAsString("a");
 812     const std::string& NodeB = Edge->getValueAsString("b");
 813
 814     if (NodeA != "root")
 815       ToolsInGraph.insert(NodeA);
 816     ToolsInGraph.insert(NodeB);
 817   }
 818
 819   // Filter ToolPropertiesList.
 820   ToolDescriptions::iterator new_end =
 821     std::remove_if(ToolDescs.begin(), ToolDescs.end(),
 822                    NotInGraph(ToolsInGraph));
 823   ToolDescs.erase(new_end, ToolDescs.end());
 824 }
 825
 826 /// FillInToolToLang - Fills in two tables that map tool names to
 827 /// (input, output) languages.  Helper function used by TypecheckGraph().
 828 void FillInToolToLang (const ToolDescriptions& ToolDescs,
 829                        StringMap<StringSet<> >& ToolToInLang,
 830                        StringMap<std::string>& ToolToOutLang) {
 831   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
 832          E = ToolDescs.end(); B != E; ++B) {
 833     const ToolDescription& D = *(*B);
 834     for (StrVector::const_iterator B = D.InLanguage.begin(),
 835            E = D.InLanguage.end(); B != E; ++B)
 836       ToolToInLang[D.Name].insert(*B);
 837     ToolToOutLang[D.Name] = D.OutLanguage;
 838   }
 839 }
 840
 841 /// TypecheckGraph - Check that names for output and input languages
 842 /// on all edges do match. This doesn't do much when the information
 843 /// about the whole graph is not available (i.e. when compiling most
 844 /// plugins).
 845 void TypecheckGraph (const RecordVector& EdgeVector,
 846                      const ToolDescriptions& ToolDescs) {
 847   StringMap<StringSet<> > ToolToInLang;
 848   StringMap<std::string> ToolToOutLang;
 849
 850   FillInToolToLang(ToolDescs, ToolToInLang, ToolToOutLang);
 851   StringMap<std::string>::iterator IAE = ToolToOutLang.end();
 852   StringMap<StringSet<> >::iterator IBE = ToolToInLang.end();
 853
 854   for (RecordVector::const_iterator B = EdgeVector.begin(),
 855          E = EdgeVector.end(); B != E; ++B) {
 856     const Record* Edge = *B;
 857     const std::string& NodeA = Edge->getValueAsString("a");
 858     const std::string& NodeB = Edge->getValueAsString("b");
 859     StringMap<std::string>::iterator IA = ToolToOutLang.find(NodeA);
 860     StringMap<StringSet<> >::iterator IB = ToolToInLang.find(NodeB);
 861
 862     if (NodeA != "root") {
 863       if (IA != IAE && IB != IBE && IB->second.count(IA->second) == 0)
 864         throw "Edge " + NodeA + "->" + NodeB
 865           + ": output->input language mismatch";
 866     }
 867
 868     if (NodeB == "root")
 869       throw std::string("Edges back to the root are not allowed!");
 870   }
 871 }
 872
 873 /// WalkCase - Walks the 'case' expression DAG and invokes
 874 /// TestCallback on every test, and StatementCallback on every
 875 /// statement. Handles 'case' nesting, but not the 'and' and 'or'
 876 /// combinators.
 877 // TODO: Re-implement EmitCaseConstructHandler on top of this function?
 878 template <typename F1, typename F2>
 879 void WalkCase(Init* Case, F1 TestCallback, F2 StatementCallback) {
 880   const DagInit& d = InitPtrToDag(Case);
 881   bool even = false;
 882   for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
 883        B != E; ++B) {
 884     Init* arg = *B;
 885     if (even && dynamic_cast<DagInit*>(arg)
 886         && static_cast<DagInit*>(arg)->getOperator()->getAsString() == "case")
 887       WalkCase(arg, TestCallback, StatementCallback);
 888     else if (!even)
 889       TestCallback(arg);
 890     else
 891       StatementCallback(arg);
 892     even = !even;
 893   }
 894 }
 895
 896 /// ExtractOptionNames - A helper function object used by
 897 /// CheckForSuperfluousOptions() to walk the 'case' DAG.
 898 class ExtractOptionNames {
 899   llvm::StringSet<>& OptionNames_;
 900
 901   void processDag(const Init* Statement) {
 902     const DagInit& Stmt = InitPtrToDag(Statement);
 903     const std::string& ActionName = Stmt.getOperator()->getAsString();
 904     if (ActionName == "forward" || ActionName == "forward_as" ||
 905         ActionName == "unpack_values" || ActionName == "switch_on" ||
 906         ActionName == "parameter_equals" || ActionName == "element_in_list" ||
 907         ActionName == "not_empty" || ActionName == "empty") {
 908       checkNumberOfArguments(&Stmt, 1);
 909       const std::string& Name = InitPtrToString(Stmt.getArg(0));
 910       OptionNames_.insert(Name);
 911     }
 912     else if (ActionName == "and" || ActionName == "or") {
 913       for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
 914         this->processDag(Stmt.getArg(i));
 915       }
 916     }
 917   }
 918
 919 public:
 920   ExtractOptionNames(llvm::StringSet<>& OptionNames) : OptionNames_(OptionNames)
 921   {}
 922
 923   void operator()(const Init* Statement) {
 924     if (typeid(*Statement) == typeid(ListInit)) {
 925       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
 926       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
 927            B != E; ++B)
 928         this->processDag(*B);
 929     }
 930     else {
 931       this->processDag(Statement);
 932     }
 933   }
 934 };
 935
 936 /// CheckForSuperfluousOptions - Check that there are no side
 937 /// effect-free options (specified only in the OptionList). Otherwise,
 938 /// output a warning.
 939 void CheckForSuperfluousOptions (const RecordVector& Edges,
 940                                  const ToolDescriptions& ToolDescs,
 941                                  const OptionDescriptions& OptDescs) {
 942   llvm::StringSet<> nonSuperfluousOptions;
 943
 944   // Add all options mentioned in the ToolDesc.Actions to the set of
 945   // non-superfluous options.
 946   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
 947          E = ToolDescs.end(); B != E; ++B) {
 948     const ToolDescription& TD = *(*B);
 949     ExtractOptionNames Callback(nonSuperfluousOptions);
 950     if (TD.Actions)
 951       WalkCase(TD.Actions, Callback, Callback);
 952   }
 953
 954   // Add all options mentioned in the 'case' clauses of the
 955   // OptionalEdges of the compilation graph to the set of
 956   // non-superfluous options.
 957   for (RecordVector::const_iterator B = Edges.begin(), E = Edges.end();
 958        B != E; ++B) {
 959     const Record* Edge = *B;
 960     DagInit* Weight = Edge->getValueAsDag("weight");
 961
 962     if (!isDagEmpty(Weight))
 963       WalkCase(Weight, ExtractOptionNames(nonSuperfluousOptions), Id());
 964   }
 965
 966   // Check that all options in OptDescs belong to the set of
 967   // non-superfluous options.
 968   for (OptionDescriptions::const_iterator B = OptDescs.begin(),
 969          E = OptDescs.end(); B != E; ++B) {
 970     const OptionDescription& Val = B->second;
 971     if (!nonSuperfluousOptions.count(Val.Name)
 972         && Val.Type != OptionType::Alias)
 973       llvm::errs() << "Warning: option '-" << Val.Name << "' has no effect! "
 974         "Probable cause: this option is specified only in the OptionList.\n";
 975   }
 976 }
 977
 978 /// EmitCaseTest1Arg - Helper function used by
 979 /// EmitCaseConstructHandler.
 980 bool EmitCaseTest1Arg(const std::string& TestName,
 981                       const DagInit& d,
 982                       const OptionDescriptions& OptDescs,
 983                       raw_ostream& O) {
 984   checkNumberOfArguments(&d, 1);
 985   const std::string& OptName = InitPtrToString(d.getArg(0));
 986
 987   if (TestName == "switch_on") {
 988     const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
 989     if (!OptDesc.isSwitch())
 990       throw OptName + ": incorrect option type - should be a switch!";
 991     O << OptDesc.GenVariableName();
 992     return true;
 993   } else if (TestName == "input_languages_contain") {
 994     O << "InLangs.count(\"" << OptName << "\") != 0";
 995     return true;
 996   } else if (TestName == "in_language") {
 997     // This works only for single-argument Tool::GenerateAction. Join
 998     // tools can process several files in different languages simultaneously.
 999
1000     // TODO: make this work with Edge::Weight (if possible).
1001     O << "LangMap.GetLanguage(inFile) == \"" << OptName << '\"';
1002     return true;
1003   } else if (TestName == "not_empty" || TestName == "empty") {
1004     const char* Test = (TestName == "empty") ? "" : "!";
1005
1006     if (OptName == "o") {
1007       O << Test << "OutputFilename.empty()";
1008       return true;
1009     }
1010     else {
1011       const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
1012       if (OptDesc.isSwitch())
1013         throw OptName
1014           + ": incorrect option type - should be a list or parameter!";
1015       O << Test << OptDesc.GenVariableName() << ".empty()";
1016       return true;
1017     }
1018   }
1019
1020   return false;
1021 }
1022
1023 /// EmitCaseTest2Args - Helper function used by
1024 /// EmitCaseConstructHandler.
1025 bool EmitCaseTest2Args(const std::string& TestName,
1026                        const DagInit& d,
1027                        const char* IndentLevel,
1028                        const OptionDescriptions& OptDescs,
1029                        raw_ostream& O) {
1030   checkNumberOfArguments(&d, 2);
1031   const std::string& OptName = InitPtrToString(d.getArg(0));
1032   const std::string& OptArg = InitPtrToString(d.getArg(1));
1033   const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
1034
1035   if (TestName == "parameter_equals") {
1036     if (!OptDesc.isParameter())
1037       throw OptName + ": incorrect option type - should be a parameter!";
1038     O << OptDesc.GenVariableName() << " == \"" << OptArg << "\"";
1039     return true;
1040   }
1041   else if (TestName == "element_in_list") {
1042     if (!OptDesc.isList())
1043       throw OptName + ": incorrect option type - should be a list!";
1044     const std::string& VarName = OptDesc.GenVariableName();
1045     O << "std::find(" << VarName << ".begin(),\n"
1046       << IndentLevel << Indent1 << VarName << ".end(), \""
1047       << OptArg << "\") != " << VarName << ".end()";
1048     return true;
1049   }
1050
1051   return false;
1052 }
1053
1054 // Forward declaration.
1055 // EmitLogicalOperationTest and EmitCaseTest are mutually recursive.
1056 void EmitCaseTest(const DagInit& d, const char* IndentLevel,
1057                   const OptionDescriptions& OptDescs,
1058                   raw_ostream& O);
1059
1060 /// EmitLogicalOperationTest - Helper function used by
1061 /// EmitCaseConstructHandler.
1062 void EmitLogicalOperationTest(const DagInit& d, const char* LogicOp,
1063                               const char* IndentLevel,
1064                               const OptionDescriptions& OptDescs,
1065                               raw_ostream& O) {
1066   O << '(';
1067   for (unsigned j = 0, NumArgs = d.getNumArgs(); j < NumArgs; ++j) {
1068     const DagInit& InnerTest = InitPtrToDag(d.getArg(j));
1069     EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1070     if (j != NumArgs - 1)
1071       O << ")\n" << IndentLevel << Indent1 << ' ' << LogicOp << " (";
1072     else
1073       O << ')';
1074   }
1075 }
1076
1077 /// EmitCaseTest - Helper function used by EmitCaseConstructHandler.
1078 void EmitCaseTest(const DagInit& d, const char* IndentLevel,
1079                   const OptionDescriptions& OptDescs,
1080                   raw_ostream& O) {
1081   const std::string& TestName = d.getOperator()->getAsString();
1082
1083   if (TestName == "and")
1084     EmitLogicalOperationTest(d, "&&", IndentLevel, OptDescs, O);
1085   else if (TestName == "or")
1086     EmitLogicalOperationTest(d, "||", IndentLevel, OptDescs, O);
1087   else if (EmitCaseTest1Arg(TestName, d, OptDescs, O))
1088     return;
1089   else if (EmitCaseTest2Args(TestName, d, IndentLevel, OptDescs, O))
1090     return;
1091   else
1092     throw TestName + ": unknown edge property!";
1093 }
1094
1095 // Emit code that handles the 'case' construct.
1096 // Takes a function object that should emit code for every case clause.
1097 // Callback's type is
1098 // void F(Init* Statement, const char* IndentLevel, raw_ostream& O).
1099 template <typename F>
1100 void EmitCaseConstructHandler(const Init* Dag, const char* IndentLevel,
1101                               F Callback, bool EmitElseIf,
1102                               const OptionDescriptions& OptDescs,
1103                               raw_ostream& O) {
1104   const DagInit* d = &InitPtrToDag(Dag);
1105   if (d->getOperator()->getAsString() != "case")
1106     throw std::string("EmitCaseConstructHandler should be invoked"
1107                       " only on 'case' expressions!");
1108
1109   unsigned numArgs = d->getNumArgs();
1110   if (d->getNumArgs() < 2)
1111     throw "There should be at least one clause in the 'case' expression:\n"
1112       + d->getAsString();
1113
1114   for (unsigned i = 0; i != numArgs; ++i) {
1115     const DagInit& Test = InitPtrToDag(d->getArg(i));
1116
1117     // Emit the test.
1118     if (Test.getOperator()->getAsString() == "default") {
1119       if (i+2 != numArgs)
1120         throw std::string("The 'default' clause should be the last in the"
1121                           "'case' construct!");
1122       O << IndentLevel << "else {\n";
1123     }
1124     else {
1125       O << IndentLevel << ((i != 0 && EmitElseIf) ? "else if (" : "if (");
1126       EmitCaseTest(Test, IndentLevel, OptDescs, O);
1127       O << ") {\n";
1128     }
1129
1130     // Emit the corresponding statement.
1131     ++i;
1132     if (i == numArgs)
1133       throw "Case construct handler: no corresponding action "
1134         "found for the test " + Test.getAsString() + '!';
1135
1136     Init* arg = d->getArg(i);
1137     const DagInit* nd = dynamic_cast<DagInit*>(arg);
1138     if (nd && (nd->getOperator()->getAsString() == "case")) {
1139       // Handle the nested 'case'.
1140       EmitCaseConstructHandler(nd, (std::string(IndentLevel) + Indent1).c_str(),
1141                                Callback, EmitElseIf, OptDescs, O);
1142     }
1143     else {
1144       Callback(arg, (std::string(IndentLevel) + Indent1).c_str(), O);
1145     }
1146     O << IndentLevel << "}\n";
1147   }
1148 }
1149
1150 /// TokenizeCmdline - converts from "$CALL(HookName, 'Arg1', 'Arg2')/path" to
1151 /// ["$CALL(", "HookName", "Arg1", "Arg2", ")/path"] .
1152 /// Helper function used by EmitCmdLineVecFill and.
1153 void TokenizeCmdline(const std::string& CmdLine, StrVector& Out) {
1154   const char* Delimiters = " \t\n\v\f\r";
1155   enum TokenizerState
1156   { Normal, SpecialCommand, InsideSpecialCommand, InsideQuotationMarks }
1157   cur_st  = Normal;
1158
1159   if (CmdLine.empty())
1160     return;
1161   Out.push_back("");
1162
1163   std::string::size_type B = CmdLine.find_first_not_of(Delimiters),
1164     E = CmdLine.size();
1165
1166   for (; B != E; ++B) {
1167     char cur_ch = CmdLine[B];
1168
1169     switch (cur_st) {
1170     case Normal:
1171       if (cur_ch == '$') {
1172         cur_st = SpecialCommand;
1173         break;
1174       }
1175       if (oneOf(Delimiters, cur_ch)) {
1176         // Skip whitespace
1177         B = CmdLine.find_first_not_of(Delimiters, B);
1178         if (B == std::string::npos) {
1179           B = E-1;
1180           continue;
1181         }
1182         --B;
1183         Out.push_back("");
1184         continue;
1185       }
1186       break;
1187
1188
1189     case SpecialCommand:
1190       if (oneOf(Delimiters, cur_ch)) {
1191         cur_st = Normal;
1192         Out.push_back("");
1193         continue;
1194       }
1195       if (cur_ch == '(') {
1196         Out.push_back("");
1197         cur_st = InsideSpecialCommand;
1198         continue;
1199       }
1200       break;
1201
1202     case InsideSpecialCommand:
1203       if (oneOf(Delimiters, cur_ch)) {
1204         continue;
1205       }
1206       if (cur_ch == '\'') {
1207         cur_st = InsideQuotationMarks;
1208         Out.push_back("");
1209         continue;
1210       }
1211       if (cur_ch == ')') {
1212         cur_st = Normal;
1213         Out.push_back("");
1214       }
1215       if (cur_ch == ',') {
1216         continue;
1217       }
1218
1219       break;
1220
1221     case InsideQuotationMarks:
1222       if (cur_ch == '\'') {
1223         cur_st = InsideSpecialCommand;
1224         continue;
1225       }
1226       break;
1227     }
1228
1229     Out.back().push_back(cur_ch);
1230   }
1231 }
1232
1233 /// SubstituteSpecialCommands - Perform string substitution for $CALL
1234 /// and $ENV. Helper function used by EmitCmdLineVecFill().
1235 StrVector::const_iterator SubstituteSpecialCommands
1236 (StrVector::const_iterator Pos, StrVector::const_iterator End, raw_ostream& O)
1237 {
1238
1239   const std::string& cmd = *Pos;
1240
1241   if (cmd == "$CALL") {
1242     checkedIncrement(Pos, End, "Syntax error in $CALL invocation!");
1243     const std::string& CmdName = *Pos;
1244
1245     if (CmdName == ")")
1246       throw std::string("$CALL invocation: empty argument list!");
1247
1248     O << "hooks::";
1249     O << CmdName << "(";
1250
1251
1252     bool firstIteration = true;
1253     while (true) {
1254       checkedIncrement(Pos, End, "Syntax error in $CALL invocation!");
1255       const std::string& Arg = *Pos;
1256       assert(Arg.size() != 0);
1257
1258       if (Arg[0] == ')')
1259         break;
1260
1261       if (firstIteration)
1262         firstIteration = false;
1263       else
1264         O << ", ";
1265
1266       O << '"' << Arg << '"';
1267     }
1268
1269     O << ')';
1270
1271   }
1272   else if (cmd == "$ENV") {
1273     checkedIncrement(Pos, End, "Syntax error in $ENV invocation!");
1274     const std::string& EnvName = *Pos;
1275
1276     if (EnvName == ")")
1277       throw "$ENV invocation: empty argument list!";
1278
1279     O << "checkCString(std::getenv(\"";
1280     O << EnvName;
1281     O << "\"))";
1282
1283     checkedIncrement(Pos, End, "Syntax error in $ENV invocation!");
1284   }
1285   else {
1286     throw "Unknown special command: " + cmd;
1287   }
1288
1289   const std::string& Leftover = *Pos;
1290   assert(Leftover.at(0) == ')');
1291   if (Leftover.size() != 1)
1292     O << " + std::string(\"" << (Leftover.c_str() + 1) << "\")";
1293
1294   return Pos;
1295 }
1296
1297 /// EmitCmdLineVecFill - Emit code that fills in the command line
1298 /// vector. Helper function used by EmitGenerateActionMethod().
1299 void EmitCmdLineVecFill(const Init* CmdLine, const std::string& ToolName,
1300                         bool IsJoin, const char* IndentLevel,
1301                         raw_ostream& O) {
1302   StrVector StrVec;
1303   TokenizeCmdline(InitPtrToString(CmdLine), StrVec);
1304
1305   if (StrVec.empty())
1306     throw "Tool '" + ToolName + "' has empty command line!";
1307
1308   StrVector::const_iterator I = StrVec.begin(), E = StrVec.end();
1309
1310   // If there is a hook invocation on the place of the first command, skip it.
1311   assert(!StrVec[0].empty());
1312   if (StrVec[0][0] == '$') {
1313     while (I != E && (*I)[0] != ')' )
1314       ++I;
1315
1316     // Skip the ')' symbol.
1317     ++I;
1318   }
1319   else {
1320     ++I;
1321   }
1322
1323   for (; I != E; ++I) {
1324     const std::string& cmd = *I;
1325     assert(!cmd.empty());
1326     O << IndentLevel;
1327     if (cmd.at(0) == '$') {
1328       if (cmd == "$INFILE") {
1329         if (IsJoin)
1330           O << "for (PathVector::const_iterator B = inFiles.begin()"
1331             << ", E = inFiles.end();\n"
1332             << IndentLevel << "B != E; ++B)\n"
1333             << IndentLevel << Indent1 << "vec.push_back(B->toString());\n";
1334         else
1335           O << "vec.push_back(inFile.toString());\n";
1336       }
1337       else if (cmd == "$OUTFILE") {
1338         O << "vec.push_back(out_file);\n";
1339       }
1340       else {
1341         O << "vec.push_back(";
1342         I = SubstituteSpecialCommands(I, E, O);
1343         O << ");\n";
1344       }
1345     }
1346     else {
1347       O << "vec.push_back(\"" << cmd << "\");\n";
1348     }
1349   }
1350   O << IndentLevel << "cmd = ";
1351
1352   if (StrVec[0][0] == '$')
1353     SubstituteSpecialCommands(StrVec.begin(), StrVec.end(), O);
1354   else
1355     O << '"' << StrVec[0] << '"';
1356   O << ";\n";
1357 }
1358
1359 /// EmitCmdLineVecFillCallback - A function object wrapper around
1360 /// EmitCmdLineVecFill(). Used by EmitGenerateActionMethod() as an
1361 /// argument to EmitCaseConstructHandler().
1362 class EmitCmdLineVecFillCallback {
1363   bool IsJoin;
1364   const std::string& ToolName;
1365  public:
1366   EmitCmdLineVecFillCallback(bool J, const std::string& TN)
1367     : IsJoin(J), ToolName(TN) {}
1368
1369   void operator()(const Init* Statement, const char* IndentLevel,
1370                   raw_ostream& O) const
1371   {
1372     EmitCmdLineVecFill(Statement, ToolName, IsJoin,
1373                        IndentLevel, O);
1374   }
1375 };
1376
1377 /// EmitForwardOptionPropertyHandlingCode - Helper function used to
1378 /// implement EmitActionHandler. Emits code for
1379 /// handling the (forward) and (forward_as) option properties.
1380 void EmitForwardOptionPropertyHandlingCode (const OptionDescription& D,
1381                                             const char* Indent,
1382                                             const std::string& NewName,
1383                                             raw_ostream& O) {
1384   const std::string& Name = NewName.empty()
1385     ? ("-" + D.Name)
1386     : NewName;
1387
1388   switch (D.Type) {
1389   case OptionType::Switch:
1390     O << Indent << "vec.push_back(\"" << Name << "\");\n";
1391     break;
1392   case OptionType::Parameter:
1393     O << Indent << "vec.push_back(\"" << Name << "\");\n";
1394     O << Indent << "vec.push_back(" << D.GenVariableName() << ");\n";
1395     break;
1396   case OptionType::Prefix:
1397     O << Indent << "vec.push_back(\"" << Name << "\" + "
1398       << D.GenVariableName() << ");\n";
1399     break;
1400   case OptionType::PrefixList:
1401     O << Indent << "for (" << D.GenTypeDeclaration()
1402       << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1403       << Indent << "E = " << D.GenVariableName() << ".end(); B != E;) {\n"
1404       << Indent << Indent1 << "vec.push_back(\"" << Name << "\" + "
1405       << "*B);\n"
1406       << Indent << Indent1 << "++B;\n";
1407
1408     for (int i = 1, j = D.MultiVal; i < j; ++i) {
1409       O << Indent << Indent1 << "vec.push_back(*B);\n"
1410         << Indent << Indent1 << "++B;\n";
1411     }
1412
1413     O << Indent << "}\n";
1414     break;
1415   case OptionType::ParameterList:
1416     O << Indent << "for (" << D.GenTypeDeclaration()
1417       << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1418       << Indent << "E = " << D.GenVariableName()
1419       << ".end() ; B != E;) {\n"
1420       << Indent << Indent1 << "vec.push_back(\"" << Name << "\");\n";
1421
1422     for (int i = 0, j = D.MultiVal; i < j; ++i) {
1423       O << Indent << Indent1 << "vec.push_back(*B);\n"
1424         << Indent << Indent1 << "++B;\n";
1425     }
1426
1427     O << Indent << "}\n";
1428     break;
1429   case OptionType::Alias:
1430   default:
1431     throw std::string("Aliases are not allowed in tool option descriptions!");
1432   }
1433 }
1434
1435 /// EmitActionHandler - Emit code that handles actions. Used by
1436 /// EmitGenerateActionMethod() as an argument to
1437 /// EmitCaseConstructHandler().
1438 class EmitActionHandler {
1439   const OptionDescriptions& OptDescs;
1440
1441   void processActionDag(const Init* Statement, const char* IndentLevel,
1442                         raw_ostream& O) const
1443   {
1444     const DagInit& Dag = InitPtrToDag(Statement);
1445     const std::string& ActionName = Dag.getOperator()->getAsString();
1446
1447     if (ActionName == "append_cmd") {
1448       checkNumberOfArguments(&Dag, 1);
1449       const std::string& Cmd = InitPtrToString(Dag.getArg(0));
1450       StrVector Out;
1451       llvm::SplitString(Cmd, Out);
1452
1453       for (StrVector::const_iterator B = Out.begin(), E = Out.end();
1454            B != E; ++B)
1455         O << IndentLevel << "vec.push_back(\"" << *B << "\");\n";
1456     }
1457     else if (ActionName == "error") {
1458       O << IndentLevel << "throw std::runtime_error(\"" <<
1459         (Dag.getNumArgs() >= 1 ? InitPtrToString(Dag.getArg(0))
1460          : "Unknown error!")
1461         << "\");\n";
1462     }
1463     else if (ActionName == "forward") {
1464       checkNumberOfArguments(&Dag, 1);
1465       const std::string& Name = InitPtrToString(Dag.getArg(0));
1466       EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
1467                                             IndentLevel, "", O);
1468     }
1469     else if (ActionName == "forward_as") {
1470       checkNumberOfArguments(&Dag, 2);
1471       const std::string& Name = InitPtrToString(Dag.getArg(0));
1472       const std::string& NewName = InitPtrToString(Dag.getArg(1));
1473       EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
1474                                             IndentLevel, NewName, O);
1475     }
1476     else if (ActionName == "output_suffix") {
1477       checkNumberOfArguments(&Dag, 1);
1478       const std::string& OutSuf = InitPtrToString(Dag.getArg(0));
1479       O << IndentLevel << "output_suffix = \"" << OutSuf << "\";\n";
1480     }
1481     else if (ActionName == "stop_compilation") {
1482       O << IndentLevel << "stop_compilation = true;\n";
1483     }
1484     else if (ActionName == "unpack_values") {
1485       checkNumberOfArguments(&Dag, 1);
1486       const std::string& Name = InitPtrToString(Dag.getArg(0));
1487       const OptionDescription& D = OptDescs.FindOption(Name);
1488
1489       if (D.isMultiVal())
1490         throw std::string("Can't use unpack_values with multi-valued options!");
1491
1492       if (D.isList()) {
1493         O << IndentLevel << "for (" << D.GenTypeDeclaration()
1494           << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1495           << IndentLevel << "E = " << D.GenVariableName()
1496           << ".end(); B != E; ++B)\n"
1497           << IndentLevel << Indent1 << "llvm::SplitString(*B, vec, \",\");\n";
1498       }
1499       else if (D.isParameter()){
1500         O << Indent3 << "llvm::SplitString("
1501           << D.GenVariableName() << ", vec, \",\");\n";
1502       }
1503       else {
1504         throw "Option '" + D.Name +
1505           "': switches can't have the 'unpack_values' property!";
1506       }
1507     }
1508     else {
1509       throw "Unknown action name: " + ActionName + "!";
1510     }
1511   }
1512  public:
1513   EmitActionHandler(const OptionDescriptions& OD)
1514     : OptDescs(OD) {}
1515
1516   void operator()(const Init* Statement, const char* IndentLevel,
1517                   raw_ostream& O) const
1518   {
1519     if (typeid(*Statement) == typeid(ListInit)) {
1520       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
1521       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
1522            B != E; ++B)
1523         this->processActionDag(*B, IndentLevel, O);
1524     }
1525     else {
1526       this->processActionDag(Statement, IndentLevel, O);
1527     }
1528   }
1529 };
1530
1531 // EmitGenerateActionMethod - Emit one of two versions of the
1532 // Tool::GenerateAction() method.
1533 void EmitGenerateActionMethod (const ToolDescription& D,
1534                                const OptionDescriptions& OptDescs,
1535                                bool IsJoin, raw_ostream& O) {
1536   if (IsJoin)
1537     O << Indent1 << "Action GenerateAction(const PathVector& inFiles,\n";
1538   else
1539     O << Indent1 << "Action GenerateAction(const sys::Path& inFile,\n";
1540
1541   O << Indent2 << "bool HasChildren,\n"
1542     << Indent2 << "const llvm::sys::Path& TempDir,\n"
1543     << Indent2 << "const InputLanguagesSet& InLangs,\n"
1544     << Indent2 << "const LanguageMap& LangMap) const\n"
1545     << Indent1 << "{\n"
1546     << Indent2 << "std::string cmd;\n"
1547     << Indent2 << "std::vector<std::string> vec;\n"
1548     << Indent2 << "bool stop_compilation = !HasChildren;\n"
1549     << Indent2 << "const char* output_suffix = \"" << D.OutputSuffix << "\";\n"
1550     << Indent2 << "std::string out_file;\n\n";
1551
1552   // For every understood option, emit handling code.
1553   if (D.Actions)
1554     EmitCaseConstructHandler(D.Actions, Indent2, EmitActionHandler(OptDescs),
1555                              false, OptDescs, O);
1556
1557   O << '\n' << Indent2
1558     << "out_file = OutFilename(" << (IsJoin ? "sys::Path(),\n" : "inFile,\n")
1559     << Indent3 << "TempDir, stop_compilation, output_suffix).toString();\n\n";
1560
1561   // cmd_line is either a string or a 'case' construct.
1562   if (!D.CmdLine)
1563     throw "Tool " + D.Name + " has no cmd_line property!";
1564   else if (typeid(*D.CmdLine) == typeid(StringInit))
1565     EmitCmdLineVecFill(D.CmdLine, D.Name, IsJoin, Indent2, O);
1566   else
1567     EmitCaseConstructHandler(D.CmdLine, Indent2,
1568                              EmitCmdLineVecFillCallback(IsJoin, D.Name),
1569                              true, OptDescs, O);
1570
1571   // Handle the Sink property.
1572   if (D.isSink()) {
1573     O << Indent2 << "if (!" << SinkOptionName << ".empty()) {\n"
1574       << Indent3 << "vec.insert(vec.end(), "
1575       << SinkOptionName << ".begin(), " << SinkOptionName << ".end());\n"
1576       << Indent2 << "}\n";
1577   }
1578
1579   O << Indent2 << "return Action(cmd, vec, stop_compilation, out_file);\n"
1580     << Indent1 << "}\n\n";
1581 }
1582
1583 /// EmitGenerateActionMethods - Emit two GenerateAction() methods for
1584 /// a given Tool class.
1585 void EmitGenerateActionMethods (const ToolDescription& ToolDesc,
1586                                 const OptionDescriptions& OptDescs,
1587                                 raw_ostream& O) {
1588   if (!ToolDesc.isJoin())
1589     O << Indent1 << "Action GenerateAction(const PathVector& inFiles,\n"
1590       << Indent2 << "bool HasChildren,\n"
1591       << Indent2 << "const llvm::sys::Path& TempDir,\n"
1592       << Indent2 << "const InputLanguagesSet& InLangs,\n"
1593       << Indent2 << "const LanguageMap& LangMap) const\n"
1594       << Indent1 << "{\n"
1595       << Indent2 << "throw std::runtime_error(\"" << ToolDesc.Name
1596       << " is not a Join tool!\");\n"
1597       << Indent1 << "}\n\n";
1598   else
1599     EmitGenerateActionMethod(ToolDesc, OptDescs, true, O);
1600
1601   EmitGenerateActionMethod(ToolDesc, OptDescs, false, O);
1602 }
1603
1604 /// EmitInOutLanguageMethods - Emit the [Input,Output]Language()
1605 /// methods for a given Tool class.
1606 void EmitInOutLanguageMethods (const ToolDescription& D, raw_ostream& O) {
1607   O << Indent1 << "const char** InputLanguages() const {\n"
1608     << Indent2 << "return InputLanguages_;\n"
1609     << Indent1 << "}\n\n";
1610
1611   if (D.OutLanguage.empty())
1612     throw "Tool " + D.Name + " has no 'out_language' property!";
1613
1614   O << Indent1 << "const char* OutputLanguage() const {\n"
1615     << Indent2 << "return \"" << D.OutLanguage << "\";\n"
1616     << Indent1 << "}\n\n";
1617 }
1618
1619 /// EmitNameMethod - Emit the Name() method for a given Tool class.
1620 void EmitNameMethod (const ToolDescription& D, raw_ostream& O) {
1621   O << Indent1 << "const char* Name() const {\n"
1622     << Indent2 << "return \"" << D.Name << "\";\n"
1623     << Indent1 << "}\n\n";
1624 }
1625
1626 /// EmitIsJoinMethod - Emit the IsJoin() method for a given Tool
1627 /// class.
1628 void EmitIsJoinMethod (const ToolDescription& D, raw_ostream& O) {
1629   O << Indent1 << "bool IsJoin() const {\n";
1630   if (D.isJoin())
1631     O << Indent2 << "return true;\n";
1632   else
1633     O << Indent2 << "return false;\n";
1634   O << Indent1 << "}\n\n";
1635 }
1636
1637 /// EmitStaticMemberDefinitions - Emit static member definitions for a
1638 /// given Tool class.
1639 void EmitStaticMemberDefinitions(const ToolDescription& D, raw_ostream& O) {
1640   if (D.InLanguage.empty())
1641     throw "Tool " + D.Name + " has no 'in_language' property!";
1642
1643   O << "const char* " << D.Name << "::InputLanguages_[] = {";
1644   for (StrVector::const_iterator B = D.InLanguage.begin(),
1645          E = D.InLanguage.end(); B != E; ++B)
1646     O << '\"' << *B << "\", ";
1647   O << "0};\n\n";
1648 }
1649
1650 /// EmitToolClassDefinition - Emit a Tool class definition.
1651 void EmitToolClassDefinition (const ToolDescription& D,
1652                               const OptionDescriptions& OptDescs,
1653                               raw_ostream& O) {
1654   if (D.Name == "root")
1655     return;
1656
1657   // Header
1658   O << "class " << D.Name << " : public ";
1659   if (D.isJoin())
1660     O << "JoinTool";
1661   else
1662     O << "Tool";
1663
1664   O << "{\nprivate:\n"
1665     << Indent1 << "static const char* InputLanguages_[];\n\n";
1666
1667   O << "public:\n";
1668   EmitNameMethod(D, O);
1669   EmitInOutLanguageMethods(D, O);
1670   EmitIsJoinMethod(D, O);
1671   EmitGenerateActionMethods(D, OptDescs, O);
1672
1673   // Close class definition
1674   O << "};\n";
1675
1676   EmitStaticMemberDefinitions(D, O);
1677
1678 }
1679
1680 /// EmitOptionDefinitions - Iterate over a list of option descriptions
1681 /// and emit registration code.
1682 void EmitOptionDefinitions (const OptionDescriptions& descs,
1683                             bool HasSink, bool HasExterns,
1684                             raw_ostream& O)
1685 {
1686   std::vector<OptionDescription> Aliases;
1687
1688   // Emit static cl::Option variables.
1689   for (OptionDescriptions::const_iterator B = descs.begin(),
1690          E = descs.end(); B!=E; ++B) {
1691     const OptionDescription& val = B->second;
1692
1693     if (val.Type == OptionType::Alias) {
1694       Aliases.push_back(val);
1695       continue;
1696     }
1697
1698     if (val.isExtern())
1699       O << "extern ";
1700
1701     O << val.GenTypeDeclaration() << ' '
1702       << val.GenVariableName();
1703
1704     if (val.isExtern()) {
1705       O << ";\n";
1706       continue;
1707     }
1708
1709     O << "(\"" << val.Name << "\"\n";
1710
1711     if (val.Type == OptionType::Prefix || val.Type == OptionType::PrefixList)
1712       O << ", cl::Prefix";
1713
1714     if (val.isRequired()) {
1715       if (val.isList() && !val.isMultiVal())
1716         O << ", cl::OneOrMore";
1717       else
1718         O << ", cl::Required";
1719     }
1720     else if (val.isOneOrMore() && val.isList()) {
1721         O << ", cl::OneOrMore";
1722     }
1723     else if (val.isZeroOrOne() && val.isList()) {
1724         O << ", cl::ZeroOrOne";
1725     }
1726
1727     if (val.isReallyHidden()) {
1728       O << ", cl::ReallyHidden";
1729     }
1730     else if (val.isHidden()) {
1731       O << ", cl::Hidden";
1732     }
1733
1734     if (val.MultiVal > 1)
1735       O << ", cl::multi_val(" << val.MultiVal << ')';
1736
1737     if (val.InitVal) {
1738       const std::string& str = val.InitVal->getAsString();
1739       O << ", cl::init(" << str << ')';
1740     }
1741
1742     if (!val.Help.empty())
1743       O << ", cl::desc(\"" << val.Help << "\")";
1744
1745     O << ");\n\n";
1746   }
1747
1748   // Emit the aliases (they should go after all the 'proper' options).
1749   for (std::vector<OptionDescription>::const_iterator
1750          B = Aliases.begin(), E = Aliases.end(); B != E; ++B) {
1751     const OptionDescription& val = *B;
1752
1753     O << val.GenTypeDeclaration() << ' '
1754       << val.GenVariableName()
1755       << "(\"" << val.Name << '\"';
1756
1757     const OptionDescription& D = descs.FindOption(val.Help);
1758     O << ", cl::aliasopt(" << D.GenVariableName() << ")";
1759
1760     O << ", cl::desc(\"" << "An alias for -" + val.Help  << "\"));\n";
1761   }
1762
1763   // Emit the sink option.
1764   if (HasSink)
1765     O << (HasExterns ? "extern cl" : "cl")
1766       << "::list<std::string> " << SinkOptionName
1767       << (HasExterns ? ";\n" : "(cl::Sink);\n");
1768
1769   O << '\n';
1770 }
1771
1772 /// EmitPopulateLanguageMap - Emit the PopulateLanguageMap() function.
1773 void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O)
1774 {
1775   // Generate code
1776   O << "void PopulateLanguageMapLocal(LanguageMap& langMap) {\n";
1777
1778   // Get the relevant field out of RecordKeeper
1779   const Record* LangMapRecord = Records.getDef("LanguageMap");
1780
1781   // It is allowed for a plugin to have no language map.
1782   if (LangMapRecord) {
1783
1784     ListInit* LangsToSuffixesList = LangMapRecord->getValueAsListInit("map");
1785     if (!LangsToSuffixesList)
1786       throw std::string("Error in the language map definition!");
1787
1788     for (unsigned i = 0; i < LangsToSuffixesList->size(); ++i) {
1789       const Record* LangToSuffixes = LangsToSuffixesList->getElementAsRecord(i);
1790
1791       const std::string& Lang = LangToSuffixes->getValueAsString("lang");
1792       const ListInit* Suffixes = LangToSuffixes->getValueAsListInit("suffixes");
1793
1794       for (unsigned i = 0; i < Suffixes->size(); ++i)
1795         O << Indent1 << "langMap[\""
1796           << InitPtrToString(Suffixes->getElement(i))
1797           << "\"] = \"" << Lang << "\";\n";
1798     }
1799   }
1800
1801   O << "}\n\n";
1802 }
1803
1804 /// IncDecWeight - Helper function passed to EmitCaseConstructHandler()
1805 /// by EmitEdgeClass().
1806 void IncDecWeight (const Init* i, const char* IndentLevel,
1807                    raw_ostream& O) {
1808   const DagInit& d = InitPtrToDag(i);
1809   const std::string& OpName = d.getOperator()->getAsString();
1810
1811   if (OpName == "inc_weight") {
1812     O << IndentLevel << "ret += ";
1813   }
1814   else if (OpName == "dec_weight") {
1815     O << IndentLevel << "ret -= ";
1816   }
1817   else if (OpName == "error") {
1818     O << IndentLevel << "throw std::runtime_error(\"" <<
1819         (d.getNumArgs() >= 1 ? InitPtrToString(d.getArg(0))
1820          : "Unknown error!")
1821       << "\");\n";
1822     return;
1823   }
1824
1825   else
1826     throw "Unknown operator in edge properties list: " + OpName + '!' +
1827       "\nOnly 'inc_weight', 'dec_weight' and 'error' are allowed.";
1828
1829   if (d.getNumArgs() > 0)
1830     O << InitPtrToInt(d.getArg(0)) << ";\n";
1831   else
1832     O << "2;\n";
1833
1834 }
1835
1836 /// EmitEdgeClass - Emit a single Edge# class.
1837 void EmitEdgeClass (unsigned N, const std::string& Target,
1838                     DagInit* Case, const OptionDescriptions& OptDescs,
1839                     raw_ostream& O) {
1840
1841   // Class constructor.
1842   O << "class Edge" << N << ": public Edge {\n"
1843     << "public:\n"
1844     << Indent1 << "Edge" << N << "() : Edge(\"" << Target
1845     << "\") {}\n\n"
1846
1847   // Function Weight().
1848     << Indent1 << "unsigned Weight(const InputLanguagesSet& InLangs) const {\n"
1849     << Indent2 << "unsigned ret = 0;\n";
1850
1851   // Handle the 'case' construct.
1852   EmitCaseConstructHandler(Case, Indent2, IncDecWeight, false, OptDescs, O);
1853
1854   O << Indent2 << "return ret;\n"
1855     << Indent1 << "};\n\n};\n\n";
1856 }
1857
1858 /// EmitEdgeClasses - Emit Edge* classes that represent graph edges.
1859 void EmitEdgeClasses (const RecordVector& EdgeVector,
1860                       const OptionDescriptions& OptDescs,
1861                       raw_ostream& O) {
1862   int i = 0;
1863   for (RecordVector::const_iterator B = EdgeVector.begin(),
1864          E = EdgeVector.end(); B != E; ++B) {
1865     const Record* Edge = *B;
1866     const std::string& NodeB = Edge->getValueAsString("b");
1867     DagInit* Weight = Edge->getValueAsDag("weight");
1868
1869     if (!isDagEmpty(Weight))
1870       EmitEdgeClass(i, NodeB, Weight, OptDescs, O);
1871     ++i;
1872   }
1873 }
1874
1875 /// EmitPopulateCompilationGraph - Emit the PopulateCompilationGraph()
1876 /// function.
1877 void EmitPopulateCompilationGraph (const RecordVector& EdgeVector,
1878                                    const ToolDescriptions& ToolDescs,
1879                                    raw_ostream& O)
1880 {
1881   O << "void PopulateCompilationGraphLocal(CompilationGraph& G) {\n";
1882
1883   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1884          E = ToolDescs.end(); B != E; ++B)
1885     O << Indent1 << "G.insertNode(new " << (*B)->Name << "());\n";
1886
1887   O << '\n';
1888
1889   // Insert edges.
1890
1891   int i = 0;
1892   for (RecordVector::const_iterator B = EdgeVector.begin(),
1893          E = EdgeVector.end(); B != E; ++B) {
1894     const Record* Edge = *B;
1895     const std::string& NodeA = Edge->getValueAsString("a");
1896     const std::string& NodeB = Edge->getValueAsString("b");
1897     DagInit* Weight = Edge->getValueAsDag("weight");
1898
1899     O << Indent1 << "G.insertEdge(\"" << NodeA << "\", ";
1900
1901     if (isDagEmpty(Weight))
1902       O << "new SimpleEdge(\"" << NodeB << "\")";
1903     else
1904       O << "new Edge" << i << "()";
1905
1906     O << ");\n";
1907     ++i;
1908   }
1909
1910   O << "}\n\n";
1911 }
1912
1913 /// ExtractHookNames - Extract the hook names from all instances of
1914 /// $CALL(HookName) in the provided command line string. Helper
1915 /// function used by FillInHookNames().
1916 class ExtractHookNames {
1917   llvm::StringMap<unsigned>& HookNames_;
1918 public:
1919   ExtractHookNames(llvm::StringMap<unsigned>& HookNames)
1920   : HookNames_(HookNames) {}
1921
1922   void operator()(const Init* CmdLine) {
1923     StrVector cmds;
1924     TokenizeCmdline(InitPtrToString(CmdLine), cmds);
1925     for (StrVector::const_iterator B = cmds.begin(), E = cmds.end();
1926          B != E; ++B) {
1927       const std::string& cmd = *B;
1928
1929       if (cmd == "$CALL") {
1930         unsigned NumArgs = 0;
1931         checkedIncrement(B, E, "Syntax error in $CALL invocation!");
1932         const std::string& HookName = *B;
1933
1934
1935         if (HookName.at(0) == ')')
1936           throw "$CALL invoked with no arguments!";
1937
1938         while (++B != E && B->at(0) != ')') {
1939           ++NumArgs;
1940         }
1941
1942         StringMap<unsigned>::const_iterator H = HookNames_.find(HookName);
1943
1944         if (H != HookNames_.end() && H->second != NumArgs)
1945           throw "Overloading of hooks is not allowed. Overloaded hook: "
1946             + HookName;
1947         else
1948           HookNames_[HookName] = NumArgs;
1949
1950       }
1951     }
1952   }
1953 };
1954
1955 /// FillInHookNames - Actually extract the hook names from all command
1956 /// line strings. Helper function used by EmitHookDeclarations().
1957 void FillInHookNames(const ToolDescriptions& ToolDescs,
1958                      llvm::StringMap<unsigned>& HookNames)
1959 {
1960   // For all command lines:
1961   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1962          E = ToolDescs.end(); B != E; ++B) {
1963     const ToolDescription& D = *(*B);
1964     if (!D.CmdLine)
1965       continue;
1966     if (dynamic_cast<StringInit*>(D.CmdLine))
1967       // This is a string.
1968       ExtractHookNames(HookNames).operator()(D.CmdLine);
1969     else
1970       // This is a 'case' construct.
1971       WalkCase(D.CmdLine, Id(), ExtractHookNames(HookNames));
1972   }
1973 }
1974
1975 /// EmitHookDeclarations - Parse CmdLine fields of all the tool
1976 /// property records and emit hook function declaration for each
1977 /// instance of $CALL(HookName).
1978 void EmitHookDeclarations(const ToolDescriptions& ToolDescs, raw_ostream& O) {
1979   llvm::StringMap<unsigned> HookNames;
1980
1981   FillInHookNames(ToolDescs, HookNames);
1982   if (HookNames.empty())
1983     return;
1984
1985   O << "namespace hooks {\n";
1986   for (StringMap<unsigned>::const_iterator B = HookNames.begin(),
1987          E = HookNames.end(); B != E; ++B) {
1988     O << Indent1 << "std::string " << B->first() << "(";
1989
1990     for (unsigned i = 0, j = B->second; i < j; ++i) {
1991       O << "const char* Arg" << i << (i+1 == j ? "" : ", ");
1992     }
1993
1994     O <<");\n";
1995   }
1996   O << "}\n\n";
1997 }
1998
1999 /// EmitRegisterPlugin - Emit code to register this plugin.
2000 void EmitRegisterPlugin(int Priority, raw_ostream& O) {
2001   O << "struct Plugin : public llvmc::BasePlugin {\n\n"
2002     << Indent1 << "int Priority() const { return " << Priority << "; }\n\n"
2003     << Indent1 << "void PopulateLanguageMap(LanguageMap& langMap) const\n"
2004     << Indent1 << "{ PopulateLanguageMapLocal(langMap); }\n\n"
2005     << Indent1
2006     << "void PopulateCompilationGraph(CompilationGraph& graph) const\n"
2007     << Indent1 << "{ PopulateCompilationGraphLocal(graph); }\n"
2008     << "};\n\n"
2009
2010     << "static llvmc::RegisterPlugin<Plugin> RP;\n\n";
2011 }
2012
2013 /// EmitIncludes - Emit necessary #include directives and some
2014 /// additional declarations.
2015 void EmitIncludes(raw_ostream& O) {
2016   O << "#include \"llvm/CompilerDriver/CompilationGraph.h\"\n"
2017     << "#include \"llvm/CompilerDriver/ForceLinkageMacros.h\"\n"
2018     << "#include \"llvm/CompilerDriver/Plugin.h\"\n"
2019     << "#include \"llvm/CompilerDriver/Tool.h\"\n\n"
2020
2021     << "#include \"llvm/ADT/StringExtras.h\"\n"
2022     << "#include \"llvm/Support/CommandLine.h\"\n\n"
2023
2024     << "#include <cstdlib>\n"
2025     << "#include <stdexcept>\n\n"
2026
2027     << "using namespace llvm;\n"
2028     << "using namespace llvmc;\n\n"
2029
2030     << "extern cl::opt<std::string> OutputFilename;\n\n"
2031
2032     << "inline const char* checkCString(const char* s)\n"
2033     << "{ return s == NULL ? \"\" : s; }\n\n";
2034 }
2035
2036
2037 /// PluginData - Holds all information about a plugin.
2038 struct PluginData {
2039   OptionDescriptions OptDescs;
2040   bool HasSink;
2041   bool HasExterns;
2042   ToolDescriptions ToolDescs;
2043   RecordVector Edges;
2044   int Priority;
2045 };
2046
2047 /// HasSink - Go through the list of tool descriptions and check if
2048 /// there are any with the 'sink' property set.
2049 bool HasSink(const ToolDescriptions& ToolDescs) {
2050   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2051          E = ToolDescs.end(); B != E; ++B)
2052     if ((*B)->isSink())
2053       return true;
2054
2055   return false;
2056 }
2057
2058 /// HasExterns - Go through the list of option descriptions and check
2059 /// if there are any external options.
2060 bool HasExterns(const OptionDescriptions& OptDescs) {
2061  for (OptionDescriptions::const_iterator B = OptDescs.begin(),
2062          E = OptDescs.end(); B != E; ++B)
2063     if (B->second.isExtern())
2064       return true;
2065
2066   return false;
2067 }
2068
2069 /// CollectPluginData - Collect tool and option properties,
2070 /// compilation graph edges and plugin priority from the parse tree.
2071 void CollectPluginData (const RecordKeeper& Records, PluginData& Data) {
2072   // Collect option properties.
2073   const RecordVector& OptionLists =
2074     Records.getAllDerivedDefinitions("OptionList");
2075   CollectOptionDescriptions(OptionLists.begin(), OptionLists.end(),
2076                             Data.OptDescs);
2077
2078   // Collect tool properties.
2079   const RecordVector& Tools = Records.getAllDerivedDefinitions("Tool");
2080   CollectToolDescriptions(Tools.begin(), Tools.end(), Data.ToolDescs);
2081   Data.HasSink = HasSink(Data.ToolDescs);
2082   Data.HasExterns = HasExterns(Data.OptDescs);
2083
2084   // Collect compilation graph edges.
2085   const RecordVector& CompilationGraphs =
2086     Records.getAllDerivedDefinitions("CompilationGraph");
2087   FillInEdgeVector(CompilationGraphs.begin(), CompilationGraphs.end(),
2088                    Data.Edges);
2089
2090   // Calculate the priority of this plugin.
2091   const RecordVector& Priorities =
2092     Records.getAllDerivedDefinitions("PluginPriority");
2093   Data.Priority = CalculatePriority(Priorities.begin(), Priorities.end());
2094 }
2095
2096 /// CheckPluginData - Perform some sanity checks on the collected data.
2097 void CheckPluginData(PluginData& Data) {
2098   // Filter out all tools not mentioned in the compilation graph.
2099   FilterNotInGraph(Data.Edges, Data.ToolDescs);
2100
2101   // Typecheck the compilation graph.
2102   TypecheckGraph(Data.Edges, Data.ToolDescs);
2103
2104   // Check that there are no options without side effects (specified
2105   // only in the OptionList).
2106   CheckForSuperfluousOptions(Data.Edges, Data.ToolDescs, Data.OptDescs);
2107
2108 }
2109
2110 void EmitPluginCode(const PluginData& Data, raw_ostream& O) {
2111   // Emit file header.
2112   EmitIncludes(O);
2113
2114   // Emit global option registration code.
2115   EmitOptionDefinitions(Data.OptDescs, Data.HasSink, Data.HasExterns, O);
2116
2117   // Emit hook declarations.
2118   EmitHookDeclarations(Data.ToolDescs, O);
2119
2120   O << "namespace {\n\n";
2121
2122   // Emit PopulateLanguageMap() function
2123   // (a language map maps from file extensions to language names).
2124   EmitPopulateLanguageMap(Records, O);
2125
2126   // Emit Tool classes.
2127   for (ToolDescriptions::const_iterator B = Data.ToolDescs.begin(),
2128          E = Data.ToolDescs.end(); B!=E; ++B)
2129     EmitToolClassDefinition(*(*B), Data.OptDescs, O);
2130
2131   // Emit Edge# classes.
2132   EmitEdgeClasses(Data.Edges, Data.OptDescs, O);
2133
2134   // Emit PopulateCompilationGraph() function.
2135   EmitPopulateCompilationGraph(Data.Edges, Data.ToolDescs, O);
2136
2137   // Emit code for plugin registration.
2138   EmitRegisterPlugin(Data.Priority, O);
2139
2140   O << "} // End anonymous namespace.\n\n";
2141
2142   // Force linkage magic.
2143   O << "namespace llvmc {\n";
2144   O << "LLVMC_FORCE_LINKAGE_DECL(LLVMC_PLUGIN_NAME) {}\n";
2145   O << "}\n";
2146
2147   // EOF
2148 }
2149
2150
2151 // End of anonymous namespace
2152 }
2153
2154 /// run - The back-end entry point.
2155 void LLVMCConfigurationEmitter::run (raw_ostream &O) {
2156   try {
2157   PluginData Data;
2158
2159   CollectPluginData(Records, Data);
2160   CheckPluginData(Data);
2161
2162   EmitSourceFileHeader("LLVMC Configuration Library", O);
2163   EmitPluginCode(Data, O);
2164
2165   } catch (std::exception& Error) {
2166     throw Error.what() + std::string(" - usually this means a syntax error.");
2167   }
2168 }