Every embedded processor vendor now has it's own IDE (e.g. MPLAB, Code Composer Studio, etc.) available to embedded software developers, but you shouldn't use it to compile and build your project. Here's why.
You need to be in complete control of your project build configuration.
Invariably, the IDE automatically manages some project configuration behind-the-magic-curtain to store the project settings.
Maybe the configuration is stored in XML or something and you can kind of figure out how it's supposed to work -- but without control over when or how this file is managed, you will never be in complete control of your build.
It doesn't play well with source control.
My experience with Eclipse-based IDEs has been that you can't check everything that you need to into source control. If you have several projects that go into producing a single build, the grouping of those projects is done in a workspace.
The Eclipse workspace configuration is mixed in with all of your personal configuration files, isn't readily accessible and can't be checked into source control. This is unacceptable as the workspace contains build configuration information! Thus it means that you can't just check out from source control and build, as there are some additional manual steps required.
It hinders collaboration with other developers.
When you're working with your team -- and have the project checked into source control -- it's inevitable that people are going to make changes to the project configuration.
When two simultaneous changes occur, you're going to need to manually resolve the source control conflicts generated in the project configurations. When the IDE is managing these files, this can be a real pain and extremely frustrating.
You're tired of clicking through the GUI.
You are a software developer. You already use text-based files to define the behavior of the system (i.e. source code). Why would you want to have to hunt through a GUI define the configuration for the build?
When you end up with many configuration options, it can become extremely tedious to click through the GUI to change a few settings. It's much more straight forward to cut out the magic of the IDE and create our own build system based on plain text files.
So what's the alternative?
The right way to build your project is with a checkout from source control and by running a single command from the terminal. This means everything that goes into the build is stored in source control and anyone can check it out and build it easily.
An additional benefit of this type of build is that it's scriptable. This means that you can run it automatically at any time, from anywhere -- possibly on a build server after each check-in to source control.
For embedded, C-language applications Make has traditionally been used to create this scriptable build. This is certainly an acceptable option, but there are other, similar tools which could be an improvement -- such as SCons or Rake.
So install your vendor's tools, but break out the compiler and linker manuals instead of the IDE. Find a build tool and learn how to use it to create some build scripts. This is going to take some work to set up, but it's going to save time and frustration in the long run. The first time you have to add a new developer, change build machines, or set up a build server you'll be thanking yourself.