Skip to content
  1. Jul 09, 2009
  2. Jul 08, 2009
  3. Jul 02, 2009
  4. Jul 01, 2009
  5. Jun 26, 2009
  6. Jun 25, 2009
  7. Jun 24, 2009
  8. Jun 23, 2009
  9. Jun 19, 2009
  10. Jun 16, 2009
  11. May 23, 2009
  12. May 13, 2009
    • Bill Wendling's avatar
      Change MachineInstrBuilder::addReg() to take a flag instead of a list of · f7b83c7a
      Bill Wendling authored
      booleans. This gives a better indication of what the "addReg()" is
      doing. Remembering what all of those booleans mean isn't easy, especially if you
      aren't spending all of your time in that code.
      
      I took Jakob's suggestion and made it illegal to pass in "true" for the
      flag. This should hopefully prevent any unintended misuse of this (by reverting
      to the old way of using addReg()).
      
      llvm-svn: 71722
      f7b83c7a
  13. May 09, 2009
  14. Apr 30, 2009
  15. Apr 29, 2009
    • Bill Wendling's avatar
      Second attempt: · 084669a1
      Bill Wendling authored
      Massive check in. This changes the "-fast" flag to "-O#" in llc. If you want to
      use the old behavior, the flag is -O0. This change allows for finer-grained
      control over which optimizations are run at different -O levels.
      
      Most of this work was pretty mechanical. The majority of the fixes came from
      verifying that a "fast" variable wasn't used anymore. The JIT still uses a
      "Fast" flag. I'll change the JIT with a follow-up patch.
      
      llvm-svn: 70343
      084669a1
  16. Apr 28, 2009
  17. Mar 25, 2009
  18. Mar 11, 2009
  19. Mar 07, 2009
    • Duncan Sands's avatar
      Introduce new linkage types linkonce_odr, weak_odr, common_odr · 12da8ce3
      Duncan Sands authored
      and extern_weak_odr.  These are the same as the non-odr versions,
      except that they indicate that the global will only be overridden
      by an *equivalent* global.  In C, a function with weak linkage can
      be overridden by a function which behaves completely differently.
      This means that IP passes have to skip weak functions, since any
      deductions made from the function definition might be wrong, since
      the definition could be replaced by something completely different
      at link time.   This is not allowed in C++, thanks to the ODR
      (One-Definition-Rule): if a function is replaced by another at
      link-time, then the new function must be the same as the original
      function.  If a language knows that a function or other global can
      only be overridden by an equivalent global, it can give it the
      weak_odr linkage type, and the optimizers will understand that it
      is alright to make deductions based on the function body.  The
      code generators on the other hand map weak and weak_odr linkage
      to the same thing.
      
      llvm-svn: 66339
      12da8ce3
  20. Feb 24, 2009
  21. Feb 23, 2009
  22. Feb 19, 2009
  23. Feb 18, 2009
  24. Feb 13, 2009
  25. Feb 12, 2009
  26. Feb 07, 2009
  27. Feb 06, 2009
Loading